Какой тип данных используется для хранения отдельных символов js

Типы данных JavaScript и структуры данных

Все языки программирования содержат встроенные типы данных, но они часто отличаются друг от друга в разных языках. Эта статья — попытка описать встроенные структуры (типы) данных, доступные в JavaScript, и их свойства. На их основе строятся другие структуры данных. Когда это возможно, то мы будем сравнивать типы данных в разных языках.

Динамическая типизация

JavaScript является слабо типизированным или динамическим языком. Это значит, что вам не нужно определять тип переменной заранее. Тип определится автоматически во время выполнения программы. Также это значит, что вы можете использовать одну переменную для хранения данных различных типов:

var foo = 42; // сейчас foo типа Number foo = "bar"; // а теперь foo типа String foo = true; // foo становится типа Boolean 

Типы данных

Стандарт ECMAScript определяет 8 типов:

• 6 типов данных являющихся примитивами:
  • Undefined (Неопределённый тип) : typeof instance === «undefined»
  • Boolean (Булев, Логический тип) : typeof instance === «boolean»
  • Number (Число) : typeof instance === «number»
  • String (Строка) : typeof instance === «string»
  • BigInt : typeof instance === «bigint»
  • Symbol (в ECMAScript 6) : typeof instance === «symbol»

  И здесь нам необходимо сделать предостережение относительно использования оператора typeof для определения типа структур, т.к. все структуры будут возвращать «object» при его использовании, так как назначение typeof — проверка типа данных, но не структур. Если проверить тип структуры всё же необходимо, то в этом случае желательно использовать оператор instanceof, так как именно он отвечает на вопрос о том, какой конструктор был использован для создания структуры.

  Стоит отметить два особых случая работы оператора typeof : возврат «object» для значения null и «function» для функций: первое принято считать ошибкой языка, сохраненной ради обратной совместимости, второе является условностью, удобной для проверки на принадлежность значения категории функций, где функция — это особый, «вызываемый», объект.

  Примитивные значения

  Все типы данных в JavaScript, кроме объектов, являются иммутабельными (значения не могут быть модифицированы, а только перезаписаны новым полным значением). Например, в отличии от C, где строку можно посимвольно корректировать, в JavaScript строки пересоздаются только полностью. Значения таких типов называются «примитивными значениями».

  Булевый тип данных

  Булевый тип представляет логическую сущность и имеет два значения: true (истина) и false (ложь) . Смотрите Boolean и Boolean для получения подробностей.

  Null

  Этот тип данных имеет всего одно значение: null . Смотрите null и Null для получения подробностей.

  Undefined

  Переменная, которой не было присвоено значение, будет иметь значение undefined . Смотрите undefined и undefined для получения подробностей.

  Числа

  В соответствии со стандартом ECMAScript, существует только один числовой тип, который представляет собой 64-битное число двойной точности согласно стандарту IEEE 754. Другими словами, специального типа для целых чисел в JavaScript нет. Это означает, что при числовых операциях вы можете получить неточное (округлённое) значение. В дополнение к возможности представлять числа с плавающей запятой, есть несколько символических значений: +Infinity (положительная бесконечность), -Infinity (отрицательная бесконечность), и NaN (не число).

  Для получения самого большого или самого меньшего доступного значения в пределах +/-Infinity , можно использовать константы Number.MAX_VALUE или Number.MIN_VALUE . А начиная с ECMAScript 2015, вы также можете проверить, находится ли число в безопасном для целых чисел диапазоне, используя метод Number.isSafeInteger() , либо константы Number.MAX_SAFE_INTEGER и Number.MIN_SAFE_INTEGER . За пределами этого диапазона операции с целыми числами будут небезопасными, и возвращать приближённые значения.

  Ноль в JavaScript имеет два представления: -0 и +0. («0» это синоним +0). На практике это имеет малозаметный эффект. Например, выражение +0 === -0 является истинным. Однако, это может проявиться при делении на ноль:

  > 42 / +0 Infinity > 42 / -0 -Infinity 

  Хотя число в большинстве случаев представляет только своё значение, JavaScript предоставляет несколько бинарных операций. Они могут использоваться для того, чтобы представлять число как несколько булевых значений, с помощью битовой маски. Это считается плохой практикой, так как JavaScript предлагает другие способы представления булевых значений (например, массив элементов с булевыми значениями или объект, содержащий набор булевых свойств). Кроме того, битовые маски часто делают код более трудным для чтения, понимания и дальнейшей поддержки. Эта техника может быть необходима в условиях технических ограничений, таких как объём локального хранилища данных, или в такой экстремальной ситуации, когда каждый бит передаваемый по сети на счету. Данный подход следует использовать как крайнюю меру, когда не остаётся других путей для необходимой оптимизации.

  Текстовые строки

  В JavaScript для представления текстовых данных служит тип String . Он представляет собой цепочку «элементов» 16-битных беззнаковых целочисленных значений. Каждый такой элемент занимает свою позицию в строке. Первый элемент имеет индекс 0, следующий — 1, и так далее. Длина строки — это количество элементов в ней.

  В отличие от языков подобных C, строки в JavaScript являются иммутабельными. Это означает, что после того, как строковое значение создано, его нельзя модифицировать. Остаётся лишь создать новую строку путём совершения некой операции над исходной строкой. Например:

  • Получить часть исходной строки выборкой отдельных символов, либо применением метода String.substr() .
  • Объединить две строки в одну, применив оператор ( + ) или метод String.concat() .

  Избегайте повсеместного использования строк в своём коде!

  Иногда может показаться соблазнительным использование строк для представления сложных структур данных. Это даст небольшие краткосрочные выгоды:

  • Легко соединять данные в кучу сложением строк.
  • Легко отлаживать (данные выглядят «как есть», в читаемом текстовом виде).
  • Строки — это распространённый формат данных, используемый разнообразными API (поля ввода (en-US), значения локального хранилища, XMLHttpRequest возвращает ответ в виде строки, и т. д.) и использовать только строки может показаться заманчивым.

  Несмотря на то, что в строке можно выразить данные любой сложности, делать это — не самая лучшая идея. Например, используя разделитель, строку можно использовать как список элементов (массив JavaScript будет более подходящим решением). К сожалению, если такой сепаратор встретится в значении одного из элементов, такой список будет сломан. Выходом может стать добавление символа экранирования, и т. д. Всё это потребует добавления множества ненужных правил, и станет обременительным при поддержке.

  Используйте строки только для текстовых данных. Для составных структур преобразуйте строки в подобающие конструкции.

  Тип данных Символ (Symbol)

  Символы являются нововведением JavaScript начиная с ECMAScript 2015. Символ — это уникальное и иммутабельное примитивное значение, которое может быть использовано как ключ для свойства объекта (смотрите ниже). В некоторых языках программирования символы называются атомами. Их также можно сравнить с именованными значениями перечисления (enum) в языке C. Подробнее смотрите Symbol и Symbol .

  Тип данных Большое целое (BigInt)

  BigInt является встроенным объектом, который предоставляет способ представления целых чисел, которые больше 2 53, что является наибольшим числом, которое JavaScript может надёжно представить с помощью Number примитива.

  > let bigInt = 19241924124n; > console.log(bigInt); 19241924124n > console.log(typeof bigInt); "bigint" 

  Объекты

  В компьютерной терминологии, объект — это значение в памяти, на которое возможно сослаться с помощью идентификатора.

  Свойства

  В JavaScript объект может расцениваться как набор свойств. Литеральная инициализация объекта задаёт определённое количество начальных свойств, и в процессе работы приложения поля могут добавляться и удаляться. Значения свойств могут иметь любой тип, включая другие объекты, что позволяет строить сложные, разветвлённые иерархии данных. Каждое свойство объекта идентифицируется ключом, в качестве которого может выступать значение с типом Строка или Символ.

  Есть два типа свойств: свойство-значение и свойство-акцессор (свойство, обёрнутое в геттер и сеттер). Они отличаются определёнными атрибутами.

  Свойство-значение

  Ассоциирует ключ со значением, и имеет следующие атрибуты:

  Атрибут	Тип	Описание	Значение по умолчанию
  [[Value]]	Любой тип JavaScript	Значение, возвращаемое при обращении к свойству.	undefined
  [[Writable]]	Boolean	Если false , то [[Value]] свойства не может быть изменено.	false
  [[Enumerable]]	Boolean	Если true , свойство будет перечислено в цикле for. in. Смотрите подробнее Перечисляемость и владение свойствами.	false
  [[Configurable]]	Boolean	Если false , то свойство не может быть удалено, а его атрибуты, кроме [[Value]] и [[Writable]] не могут быть изменены.	false

  Атрибут	Тип	Описание
  Read-only	Boolean	Зарезервировано по атрибуту [[Writable]] ES5.
  DontEnum	Boolean	Зарезервировано по атрибуту [[Enumerable]] ES5.
  DontDelete	Boolean	Зарезервировано по атрибуту [[Configurable]] ES5.

  Свойство-акцессор

  Ассоциирует ключ с одной из двух функций-акцессоров (геттер и сеттер) для получения или изменения значения свойства, и имеет следующий атрибуты:

  Атрибут	Тип	Описание	Значение по умолчанию
  [[Get]]	Function или undefined	Функция вызывается без параметров и возвращает значение свойства каждый раз, когда происходит чтение свойства. Смотрите также get (en-US) .	undefined
  [[Set]]	Function или undefined	Функция вызывается с одним аргументом, содержащим присваиваемое значение, каждый раз, когда происходит попытка присвоить свойству новое значение. Смотрите также set (en-US) .	undefined
  [[Enumerable]]	Boolean	Если true , свойство будет перечислено в цикле for. in.	false
  [[Configurable]]	Boolean	Если false , то свойство не может быть удалено, и не может быть преобразовано в свойство-значение.	false

  Примечание: Атрибуты обычно используются движком JavaScript, поэтому вы не можете обратиться к ним напрямую (смотрите подробнее Object.defineProperty()). Вот почему в таблицах выше они помещены в двойные квадратные скобки вместо одиночных.

  «Обычные» объекты и функции

  Объект JavaScript — это таблица соотношений между ключами и значениями. Ключи — это строки (или Symbol ), а значения могут быть любыми. Это делает объекты полностью отвечающими определению хеш-таблицы.

  Функции — это обычные объекты, имеющие дополнительную возможность быть вызванными для исполнения.

  Даты

  Для работы с датами служит встроенный глобальный объект Date .

  Массивы общие и типизированные

  Массив — это обычный объект с дополнительной связью между целочисленными ключами его свойств и специальным свойством length. Вдобавок ко всему, массивы наследуют Array.prototype , предоставляющий исчерпывающий набор методов для манипуляции массивами. Например, метод indexOf (служит для поиска значения в массиве), push (en-US) (добавляет элемент в конец массива) и т. д. Всё это делает массив идеальным кандидатом для представления списков и перечислений.

  Типизированный массив является новинкой ECMAScript Edition 6 и является массивоподобным представлением для лежащего в его основе бинарного буфера памяти. Следующая таблица поможет вам найти соответствующие типы языка C:

  Объекты TypedArray

  Тип	Диапазон значений	Размер (байты)	Описание	Тип Web IDL	Эквивалентный тип языка C
  Int8Array	-128 до 127	1	8-битное целое со знаком с дополнением до двух	byte	int8_t
  Uint8Array (en-US)	0 до 255	1	8-битное беззнаковое целое	octet	uint8_t
  Uint8ClampedArray	0 до 255	1	8-битное беззнаковое целое (фиксированное от 0 до 255)	octet	uint8_t
  Int16Array (en-US)	-32768 до 32767	2	16-битное целое со знаком с дополнением до двух	short	int16_t
  Uint16Array (en-US)	0 до 65535	2	16-битное беззнаковое целое	unsigned short	uint16_t
  Int32Array	-2147483648 до 2147483647	4	32-битное целое со знаком с дополнением до двух	long	int32_t
  Uint32Array (en-US)	0 до 4294967295	4	32-битное беззнаковое целое	unsigned long	uint32_t
  Float32Array	1.2×10-38 to 3.4×1038	4	32-битное число с плавающей точкой IEEE-стандарта (7 значащих цифр, например 1.123456)	unrestricted float	float
  Float64Array	5.0×10-324 to 1.8×10308	8	64-битное число с плавающей точкой IEEE-стандарта (16 значащих цифр, например, 1.123. 15)	unrestricted double	double

  Коллекции: Maps, Sets, WeakMaps, WeakSets

  Эти наборы данных используют ссылку на объект в качестве ключа, и введены в JavaScript с приходом ECMAScript Edition 6. Set и WeakSet являют собой набор уникальных объектов, в то время как Map (en-US) и WeakMap ассоциируют с объектом (выступающим в качестве ключа) некоторое значение. Разница между Map и WeakMap заключается в том, что только у Map ключи являются перечисляемыми. Это позволяет оптимизировать сборку мусора для WeakMap.

  Можно было бы написать собственную реализацию Map и Set на чистом ECMAScript 5. Однако, так как объекты нельзя сравнивать на больше или меньше, то производительность поиска в самодельной реализации будет вынужденно линейной. Нативная реализация (включая WeakMap) имеет производительность логарифмически близкую к константе.

  Обычно, для привязки некоторых данных к узлу DOM, приходится устанавливать свойства этому узлу непосредственно, либо использовать его атрибуты data-* . Обратной стороной такого подхода является то, что эти данные будут доступны любому скрипту, работающему в том же контексте. Maps и WeakMaps дают возможность приватной привязки данных к объекту.

  Структурированные данные: JSON

  JSON (JavaScript Object Notation) — это легковесный формат обмена данными, происходящий от JavaScript, но используемый во множестве языков программирования. JSON строит универсальные структуры данных. Смотрите JSON и JSON для детального изучения.

  Больше объектов и стандартная библиотека

  JavaScript имеет стандартную библиотеку встроенных объектов. Пожалуйста, обратитесь к справочнику, чтобы найти описание всех объектов доступных для работы.

  Определение типов оператором typeof

  Оператор typeof может помочь определить тип вашей переменной. Смотрите страницу документации, где приведены его детали и случаи использования.

  Смотрите также

  • Nicholas Zakas, коллекция некоторых классических структур данных и алгоритмов, написанных на JavaScript.
  • Реализация некоторых структур данных для JavaScript

  Found a content problem with this page?

  • Edit the page on GitHub.
  • Report the content issue.
  • View the source on GitHub.

  This page was last modified on 7 авг. 2023 г. by MDN contributors.

  Your blueprint for a better internet.

  Типы данных

  Значение в JavaScript всегда относится к данным определённого типа. Например, это может быть строка или число.

  Есть восемь основных типов данных в JavaScript. В этой главе мы рассмотрим их в общем, а в следующих главах поговорим подробнее о каждом.

  Переменная в JavaScript может содержать любые данные. В один момент там может быть строка, а в другой – число:

  // Не будет ошибкой let message = "hello"; message = 123456;

  Языки программирования, в которых такое возможно, называются «динамически типизированными». Это значит, что типы данных есть, но переменные не привязаны ни к одному из них.

  Число

  let n = 123; n = 12.345;

  Числовой тип данных ( number ) представляет как целочисленные значения, так и числа с плавающей точкой.

  Существует множество операций для чисел, например, умножение * , деление / , сложение + , вычитание — и так далее.

  Кроме обычных чисел, существуют так называемые «специальные числовые значения», которые относятся к этому типу данных: Infinity , -Infinity и NaN .

  Infinity представляет собой математическую бесконечность ∞. Это особое значение, которое больше любого числа. Мы можем получить его в результате деления на ноль:

  alert( 1 / 0 ); // Infinity

  Или задать его явно:

  alert( Infinity ); // Infinity

  alert( "не число" / 2 ); // NaN, такое деление является ошибкой

  Значение NaN «прилипчиво». Любая математическая операция с NaN возвращает NaN :

  alert( NaN + 1 ); // NaN alert( 3 * NaN ); // NaN alert( "не число" / 2 - 1 ); // NaN

  Математические операции – безопасны

  Математические операции в JavaScript «безопасны». Мы можем делать что угодно: делить на ноль, обращаться с нечисловыми строками как с числами и т.д.

  Скрипт никогда не остановится с фатальной ошибкой (не «умрёт»). В худшем случае мы получим NaN как результат выполнения.

  Специальные числовые значения относятся к типу «число». Конечно, это не числа в привычном значении этого слова.

  Подробнее о работе с числами мы поговорим в главе Числа.

  BigInt

  В JavaScript тип number не может безопасно работать с числами, большими, чем (2 53 -1) (т. е. 9007199254740991 ) или меньшими, чем -(2 53 -1) для отрицательных чисел.

  Если говорить совсем точно, то, технически, тип number может хранить большие целые числа (до 1.7976931348623157 * 10 308 ), но за пределами безопасного диапазона целых чисел ±(2 53 -1) будет ошибка точности, так как не все цифры помещаются в фиксированную 64-битную память. Поэтому можно хранить «приблизительное» значение.

  Например, эти два числа (прямо за пределами безопасного диапазона) совпадают:

  console.log(9007199254740991 + 1); // 9007199254740992 console.log(9007199254740991 + 2); // 9007199254740992

  То есть все нечетные целые числа, большие чем (2 53 -1) , вообще не могут храниться в типе number .

  В большинстве случаев безопасного диапазона чисел от -(2 53 -1) до (2 53 -1) вполне достаточно, но иногда нам требуется весь диапазон действительно гигантских целых чисел без каких-либо ограничений или пропущенных значений внутри него. Например, в криптографии или при использовании метки времени («timestamp») с микросекундами.

  Тип BigInt был добавлен в JavaScript, чтобы дать возможность работать с целыми числами произвольной длины.

  Чтобы создать значение типа BigInt , необходимо добавить n в конец числового литерала:

  // символ "n" в конце означает, что это BigInt const bigInt = 1234567890123456789012345678901234567890n;

  Так как необходимость в использовании BigInt –чисел появляется достаточно редко, мы рассмотрим их в отдельной главе BigInt. Ознакомьтесь с ней, когда вам понадобятся настолько большие числа.

  В данный момент BigInt поддерживается только в браузерах Firefox, Chrome, Edge и Safari, но не поддерживается в IE.

  Строка

  Строка ( string ) в JavaScript должна быть заключена в кавычки.

  let str = "Привет"; let str2 = 'Одинарные кавычки тоже подойдут'; let phrase = `Обратные кавычки позволяют встраивать переменные $`;

  В JavaScript существует три типа кавычек.

  1. Двойные кавычки: «Привет» .
  2. Одинарные кавычки: ‘Привет’ .
  3. Обратные кавычки: `Привет` .

  Двойные или одинарные кавычки являются «простыми», между ними нет разницы в JavaScript.

  Обратные же кавычки имеют расширенную функциональность. Они позволяют нам встраивать выражения в строку, заключая их в $ . Например:

  let name = "Иван"; // Вставим переменную alert( `Привет, $!` ); // Привет, Иван! // Вставим выражение alert( `результат: $` ); // результат: 3

  Выражение внутри $ вычисляется, и его результат становится частью строки. Мы можем положить туда всё, что угодно: переменную name , или выражение 1 + 2 , или что-то более сложное.

  Обратите внимание, что это можно делать только в обратных кавычках. Другие кавычки не имеют такой функциональности встраивания!

  alert( "результат: $" ); // результат: $ (двойные кавычки ничего не делают)

  Мы рассмотрим строки более подробно в главе Строки.

  Нет отдельного типа данных для одного символа.

  В некоторых языках, например C и Java, для хранения одного символа, например «a» или «%» , существует отдельный тип. В языках C и Java это char .

  В JavaScript подобного типа нет, есть только тип string . Строка может содержать ноль символов (быть пустой), один символ или множество.

  Булевый (логический) тип

  Булевый тип ( boolean ) может принимать только два значения: true (истина) и false (ложь).

  Такой тип, как правило, используется для хранения значений да/нет: true значит «да, правильно», а false значит «нет, не правильно».

  let nameFieldChecked = true; // да, поле отмечено let ageFieldChecked = false; // нет, поле не отмечено

  Булевые значения также могут быть результатом сравнений:

  let isGreater = 4 > 1; alert( isGreater ); // true (результатом сравнения будет "да")

  Мы рассмотрим булевые значения более подробно в главе Логические операторы.

  Значение «null»

  Специальное значение null не относится ни к одному из типов, описанных выше.

  Оно формирует отдельный тип, который содержит только значение null :

  let age = null;

  В JavaScript null не является «ссылкой на несуществующий объект» или «нулевым указателем», как в некоторых других языках.

  Это просто специальное значение, которое представляет собой «ничего», «пусто» или «значение неизвестно».

  В приведённом выше коде указано, что значение переменной age неизвестно.

  Значение «undefined»

  Специальное значение undefined также стоит особняком. Оно формирует тип из самого себя так же, как и null .

  Оно означает, что «значение не было присвоено».

  Если переменная объявлена, но ей не присвоено никакого значения, то её значением будет undefined :

  let age; alert(age); // выведет "undefined"

  Технически мы можем присвоить значение undefined любой переменной:

  let age = 123; // изменяем значение на undefined age = undefined; alert(age); // "undefined"

  …Но так делать не рекомендуется. Обычно null используется для присвоения переменной «пустого» или «неизвестного» значения, а undefined – для проверок, была ли переменная назначена.

  Объекты и символы

  Тип object (объект) – особенный.

  Все остальные типы называются «примитивными», потому что их значениями могут быть только простые значения (будь то строка, или число, или что-то ещё). В объектах же хранят коллекции данных или более сложные структуры.

  Объекты занимают важное место в языке и требуют особого внимания. Мы разберёмся с ними в главе Объекты после того, как узнаем больше о примитивах.

  Тип symbol (символ) используется для создания уникальных идентификаторов в объектах. Мы упоминаем здесь о нём для полноты картины, изучим этот тип после объектов.

  Оператор typeof

  Оператор typeof возвращает тип аргумента. Это полезно, когда мы хотим обрабатывать значения различных типов по-разному или просто хотим сделать проверку.

  У него есть две синтаксические формы:

  // Обычный синтаксис typeof 5 // Выведет "number" // Синтаксис, напоминающий вызов функции (встречается реже) typeof(5) // Также выведет "number"

  Если передается выражение, то нужно заключать его в скобки, т.к. typeof имеет более высокий приоритет, чем бинарные операторы:

  typeof 50 + " Квартир"; // Выведет "number Квартир" typeof (50 + " Квартир"); // Выведет "string"

  Другими словами, скобки необходимы для определения типа значения, которое получилось в результате выполнения выражения в них.

  Вызов typeof x возвращает строку с именем типа:

  typeof undefined // "undefined" typeof 0 // "number" typeof 10n // "bigint" typeof true // "boolean" typeof "foo" // "string" typeof Symbol("id") // "symbol" typeof Math // "object" (1) typeof null // "object" (2) typeof alert // "function" (3)

  Последние три строки нуждаются в пояснении:

  1. Math — это встроенный объект, который предоставляет математические операции и константы. Мы рассмотрим его подробнее в главе Числа. Здесь он служит лишь примером объекта.
  2. Результатом вызова typeof null является «object» . Это официально признанная ошибка в typeof , ведущая начало с времён создания JavaScript и сохранённая для совместимости. Конечно, null не является объектом. Это специальное значение с отдельным типом.
  3. Вызов typeof alert возвращает «function» , потому что alert является функцией. Мы изучим функции в следующих главах, где заодно увидим, что в JavaScript нет специального типа «функция». Функции относятся к объектному типу. Но typeof обрабатывает их особым образом, возвращая «function» . Так тоже повелось от создания JavaScript. Формально это неверно, но может быть удобным на практике.

  Итого

  В JavaScript есть 8 основных типов данных.

  • Семь из них называют «примитивными» типами данных:
    • number для любых чисел: целочисленных или чисел с плавающей точкой; целочисленные значения ограничены диапазоном ±(2 53 -1) .
    • bigint для целых чисел произвольной длины.
    • string для строк. Строка может содержать ноль или больше символов, нет отдельного символьного типа.
    • boolean для true / false .
    • null для неизвестных значений – отдельный тип, имеющий одно значение null .
    • undefined для неприсвоенных значений – отдельный тип, имеющий одно значение undefined .
    • symbol для уникальных идентификаторов.
    • object для более сложных структур данных.

    Оператор typeof позволяет нам увидеть, какой тип данных сохранён в переменной.

    • Имеет две формы: typeof x или typeof(x) .
    • Возвращает строку с именем типа. Например, «string» .
    • Для null возвращается «object» – это ошибка в языке, на самом деле это не объект.

    В следующих главах мы сконцентрируемся на примитивных значениях, а когда познакомимся с ними, перейдём к объектам.

    Какой тип данных используется для хранения отдельных символов js

    Все используемые данные в javascript имеют определенный тип. В JavaScript имеется восемь типов данных:

    • String : представляет строку
    • Number : представляет числовое значение
    • BigInt : предназначен для представления очень больших целых чисел
    • Boolean : представляет логическое значение true или false
    • Undefined : представляет одно специальное значение — undefined и указывает, что значение не установлено
    • Null : представляет одно специальное значение — null и указывает на отсутствие значения
    • Symbol : представляет уникальное значение, которое часто применяется для обращения к свойствам сложных объектов
    • Object : представляет комплексный объект

    Первые семь типов представляют примитивные типы данных. Последний тип — Object представляет сложный, комплексный тип данных, который состоит из значений примитивных типов или других объектов. Рассмотрим основные примитивные типы данных.

    Числовые данные

    Number

    Тип Number представляет числа в JavaScript, которые могут быть целыми или дробными:

    • Целые числа, например, 35. Мы можем использовать как положительные, так и отрицательные числа. Диапазон используемых чисел: от -2 53 до 2 53
    • Дробные числа (числа с плавающей точкой). В качестве разделителя дробной и целой части применяется точка, например, 3.5575 . Опять же можно использовать как положительные, так и отрицательные числа. Для чисел с плавающей точкой используется тот же диапазон: от -2 53 до 2 53

    const x = 45; const y = 123.897; const z = -0.123;

    JavaScript поддерживает возможность определять числа в двоичной, восьмеричной и шестнадцатеричной системах, что очень удобно, если нам предстоить проводить поразрядные операции с отдельными битами числа. Для определения числа в двоичной системе, перед числом указывается префикс 0b :

    const num1 = 0b1011; // число 11 в десятичной системе console.log(num1); // 11

    В данном случае константа num1 равна 0b1011 , что в десятичной системе эквивалентно 11.

    Для определения числа в восьмеричной системе, перед числом указывается префикс 0o :

    const num1 = 0o11; // число 9 в десятичной системе console.log(num1); // 9

    Для определения числа в шестнадцатеричной системе, перед числом указывается префикс 0x :

    const num1 = 0xff; // число 255 в десятичной системе console.log(num1); // 255 const num2 = 0x1A; // число 26 в десятичной системе console.log(num2); // 26

    Начиная со стандарта ECMA2021 в JavaScript для увеличения читабельности в качестве разделителя между разрядами можно использовать символ подчеркивания _:

    const num1 = 1234567; const num2 = 123_4567; // число равное num1 const num3 = 1234567890; const num4 = 12_3456_7890; // число равное num3

    Тип BigInt

    Тип BigInt добавлен в последних стандартах JavaScript для представления очень больших целых чисел, которые выходят за пределы диапазона типа number. Это не значит, что мы не можем совсем работать с большими числами с помощью типа number, но работа с ними в случае с типом number будет сопряжена с проблемами. Рассмотрим небольшой пример:

    let num = 9007199254740991 console.log(num); // 9007199254740991 console.log(num + 1); // 9007199254740992 console.log(num + 2); // 9007199254740992

    Здесь переменной num присваивается максимальное значение. И далее прибавляем к ней некоторые значения и выводим на консоль результат. И результаты могут нас смутить, особенно в случае прибавления числа 2.

    Стоит отметить, что тип Number ограничен, хотя и позволяет оперировать довольно большим диапазоном чисел. В частности, мы можем использовать специальные константы Number.MIN_VALUE и Number.MAX_VALUE для проверки минимального и максимального возможных значений для типа Number:

    console.log(Number.MIN_VALUE); // 5e-324 console.log(Number.MAX_VALUE); // 1.7976931348623157e+308

    Например, рассмотрим следующий пример:

    const num = 9223372036854775801; console.log(num); // 9223372036854776000

    В силу ограничений типа Number на консоли мы увидим несколько другое число, нежели мы присвоили константе num. Это может негативно влиять на точность в вычислениях. И для подобных подобных чисел как раз предназначен тип BigInt . Для определения числа как значения типа BigInt в конце числа добавляется суффикс n :

    let dimension = 19007n; const value = 2545n;

    Например, изменим из предыдущего примера тип number на bigint:

    const num = 9223372036854775801n; console.log(num); // 9223372036854775801n

    Теперь консоль выводит корректный результат.

    Тип Boolean

    Тип Boolean представляет булевые или логические значения true (верно) и false (ложно):

    const isAlive = true; const isDead = false;

    Строки String

    Тип String представляет строки. Для определения строк применяются кавычки, причем, можно использовать как двойные, так одинарные, так и косые кавычки. Единственно ограничение: тип закрывающей кавычки должен быть тот же, что и тип открывающей, то есть либо обе двойные, либо обе одинарные.

    const user = "Tom"; const company = 'Microsoft'; const language = `JavaScript`; console.log(user); console.log(company); console.log(language);

    Если внутри строки встречаются кавычки, то мы их должны экранировать слешем. Например, пусть у нас есть текст «Бюро «Рога и копыта»» . Теперь экранируем кавычки:

    const company = "Бюро \"Рога и копыта\"";

    Также мы можем внутри стоки использовать другой тип кавычек:

    constcompany1 = "Бюро 'Рога и копыта'"; const company2 = 'Бюро "Рога и копыта"';

    Также строка может содержать специальные символы — управляющие последовательности, которые интерпретируются определенным образом. Самые распространенные последовательности — это «\n» (перевод на другую строку) и «\t» (табуляция). Например:

    const text = "Hello METANIT.COM\nHello\tWorld"; console.log(text);

    При выводе на консоль текст из константы text будет интерпретироваться следующим образом:

    Hello METANIT.COM Hello World

    Интерполяция

    Использование косых кавычек позволяет нам применять такой прием как интерполяция — встраивать данные в строку. Например:

    const user = "Tom"; const text = `Name: $`; console.log(text); // Name: Tom

    Для встраивания значений выражений (например, значений других переменных и констант) в строку перед выражением ставится знак доллара $ , после которого в фигурных скобках указывается выражение. Так, в примере выше $ означает, что в этом месте строки надо встроить значение переменной user .

    Подобным образом можно встраивать и больше количество данных:

    const user = "Tom"; const age = 37; const isMarried = false; const text = `Name: $ Age: $ IsMarried: $`; console.log(text); // Name: Tom Age: 37 IsMarried: false

    Кроме интерполяции косые кавычки позволяют определять многострочный текст:

    const text = `Мы все учились понемногу Чему-нибудь и как-нибудь, Так воспитаньем, слава богу, У нас немудрено блеснуть.`; console.log(text);

    Консольный вывод браузера:

    Мы все учились понемногу Чему-нибудь и как-нибудь, Так воспитаньем, слава богу, У нас немудрено блеснуть.

    null и undefined

    undefined указывает, что значение не определено или не установлено. Например, когда мы только определяем переменную без присвоения ей начального значения, она представляет тип undefined:

    let email; console.log(email); // выведет undefined

    Присвоение значение null означает, что у переменной отсутствует значение:

    let email; console.log(email); // undefined email = null; console.log(email); // null

    Стоит отметить, что хотя в принципе можно переменной присвоить значение undefined , как в следующем случае:

    let email = "tome@mimimail.com"; email = undefined; // установим тип undefined console.log(email); // undefined

    Но основной смысл undefined состоит в том, что переменная неинициализирована, что обычно происходит до первого присвоения ей какого-либо значения. Поэтому обычно не предполагается, что переменной явным образом будет присваиваться значение undefined . В тоже время этот тип может быть полезен — мы можем использовать его на проверку инициализации переменной. Но если же нам надо указать, что у переменной нет никакого значения, то ей присваивается null , а не undefine .

    object

    Тип object представляет сложный объект. Простейшее определение объекта представляют фигурные скобки:

    const user = <>;

    Объект может иметь различные свойства и методы:

    const user = ; console.log(user.name);

    В данном случае объект называется user, и он имеет два свойства: name и age, которые в качестве значения принимают данные других типов. Это краткое описание объектов, более подробно объекты мы рассморим в последующих статьях.

    Слабая/динамическая типизация

    JavaScript является языком со слабой и динамической типизацией. Это значит, что переменные могут динамически менять тип. Например:

    let id; // тип undefined console.log(id); id = 45; // тип number console.log(id); id = "45"; // тип string console.log(id);

    Несмотря на то, что во втором и третьем случае консоль выведет нам число 45, но во втором случае переменная id будет представлять число, а в третьем случае — строку.

    Оператор typeof

    С помощью оператора typeof можно получить тип переменной, что может быть полезно, когда в зависимости от типа переменной необходимо выполнить те или иные действия:

    let id; console.log(typeof id); // undefined id = 45; console.log(typeof id); // number id = 45n; console.log(typeof id); // bigint id = "45"; console.log(typeof id); // string

    Стоит отметить, что для значения null оператор typeof возвращает значение «object», несмотря на то, что согласно спецификации JavaScript значение null представляет отдельный тип.

    Восемь типов данных, typeof

    Материал на этой странице устарел, поэтому скрыт из оглавления сайта.

    Более новая информация по этой теме находится на странице https://learn.javascript.ru/types.

    В JavaScript существует несколько основных типов данных.

    В этой главе мы получим о них общее представление, а позже, в соответствующих главах подробно познакомимся с использованием каждого типа в отдельности.

    Число «number»

    var n = 123; n = 12.345;

    Единый тип число используется как для целых, так и для дробных чисел.

    Существуют специальные числовые значения Infinity (бесконечность) и NaN (ошибка вычислений).

    Например, бесконечность Infinity получается при делении на ноль:

    alert( 1 / 0 ); // Infinity

    Ошибка вычислений NaN будет результатом некорректной математической операции, например:

    alert( "нечисло" * 2 ); // NaN, ошибка

    Эти значения формально принадлежат типу «число», хотя, конечно, числами в их обычном понимании не являются.

    Особенности работы с числами в JavaScript разобраны в главе Числа.

    Число «bigint»

    В JavaScript тип «number» не может содержать числа больше, чем 2 53 (или меньше, чем -2 53 для отрицательных). Это техническое ограничение вызвано их внутренним представлением. 2 53 – это достаточно большое число, состоящее из 16 цифр, поэтому чаще всего проблем не возникает. Но иногда нам нужны действительно гигантские числа, например в криптографии или при использовании метки времени («timestamp») с микросекундами.

    Тип BigInt был добавлен в JavaScript, чтобы дать возможность работать с целыми числами произвольной длины.

    Чтобы создать значение типа BigInt , необходимо добавить n в конец числового литерала:

    // символ "n" в конце означает, что это BigInt const bigInt = 1234567890123456789012345678901234567890n;

    Более подробно тип данных BigInt мы рассмотрим в отдельной главе BigInt.

    Строка «string»

    var str = "Мама мыла раму"; str = 'Одинарные кавычки тоже подойдут';

    В JavaScript одинарные и двойные кавычки равноправны. Можно использовать или те или другие.

    Тип символ не существует, есть только строка.

    В некоторых языках программирования есть специальный тип данных для одного символа. Например, в языке С это char . В JavaScript есть только тип «строка» string . Что, надо сказать, вполне удобно.

    Более подробно со строками мы познакомимся в главе Строки.

    Булевый (логический) тип «boolean»

    У него всего два значения: true (истина) и false (ложь).

    Как правило, такой тип используется для хранения значения типа да/нет, например:

    var checked = true; // поле формы помечено галочкой checked = false; // поле формы не содержит галочки

    О нём мы поговорим более подробно, когда будем обсуждать логические вычисления и условные операторы.

    Специальное значение «null»

    Значение null не относится ни к одному из типов выше, а образует свой отдельный тип, состоящий из единственного значения null :

    var age = null;

    В JavaScript null не является «ссылкой на несуществующий объект» или «нулевым указателем», как в некоторых других языках. Это просто специальное значение, которое имеет смысл «ничего» или «значение неизвестно».

    В частности, код выше говорит о том, что возраст age неизвестен.

    Специальное значение «undefined»

    Значение undefined , как и null , образует свой собственный тип, состоящий из одного этого значения. Оно имеет смысл «значение не присвоено».

    Если переменная объявлена, но в неё ничего не записано, то её значение как раз и есть undefined :

    var x; alert( x ); // выведет "undefined"

    Можно присвоить undefined и в явном виде, хотя это делается редко:

    var x = 123; x = undefined; alert( x ); // "undefined"

    В явном виде undefined обычно не присваивают, так как это противоречит его смыслу. Для записи в переменную «пустого» или «неизвестного» значения используется null .

    Символы «symbol»

    «Символ» представляет собой уникальный идентификатор.

    Создаются новые символы с помощью функции Symbol() :

    // Создаём новый символ - id let

    При создании символу можно дать описание (также называемое имя), в основном использующееся для отладки кода:

    // Создаём символ id с описанием (именем) "id" let

    Символы гарантированно уникальны. Даже если мы создадим множество символов с одинаковым описанием, это всё равно будут разные символы. Описание – это просто метка, которая ни на что не влияет.

    Например, вот два символа с одинаковым описанием – но они не равны:

    let id1 = Symbol("id"); let id2 = Symbol("id"); alert(id1 == id2); // false

    Более подробно c символами мы познакомимся в главе Тип данных Symbol.

    Объекты «object»

    Первые 7 типов называют «примитивными».

    Особняком стоит восьмой тип: «объекты».

    Он используется для коллекций данных и для объявления более сложных сущностей.

    Объявляются объекты при помощи фигурных скобок <. >, например:

    var user = < name: "Вася" >;

    Мы подробно разберём способы объявления объектов и, вообще, работу с объектами, позже, в главе Объекты.

    Оператор typeof

    Оператор typeof возвращает тип аргумента.

    У него есть два синтаксиса: со скобками и без:

    1. Синтаксис оператора: typeof x .
    2. Синтаксис функции: typeof(x) .

    Работают они одинаково, но первый синтаксис короче.

    Результатом typeof является строка, содержащая тип:

    typeof undefined // "undefined" typeof 0 // "number" typeof 1n // "bigint" typeof true // "boolean" typeof "foo" // "string" typeof Symbol() // "symbol" typeof <> // "object" typeof null // "object" (1) typeof function()<> // "function" (2)

    Последние две строки помечены, потому что typeof ведёт себя в них по-особому.

    1. Результат typeof null == «object» – это официально признанная ошибка в языке, которая сохраняется для совместимости. На самом деле null – это не объект, а отдельный тип данных.
    2. Функции мы пройдём чуть позже. Пока лишь заметим, что функции не являются отдельным базовым типом в JavaScript, а подвидом объектов. Но typeof выделяет функции отдельно, возвращая для них «function» . На практике это весьма удобно, так как позволяет легко определить функцию.

    К работе с типами мы также вернёмся более подробно в будущем, после изучения основных структур данных.

    Итого

    Есть 5 «примитивных» типов: number , string , boolean , null , undefined и 6-й тип – объекты object .

    Очень скоро мы изучим их во всех деталях.

    Оператор typeof x позволяет выяснить, какой тип находится в x , возвращая его в виде строки.

    Похожие публикации:

    1. Unreal engine 5 какой язык программирования
    2. Как вернуть string из функции c
    3. Как найти количество вершин правильного многоугольника
    4. Как удалить спрайт в pygame