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

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

  • автор:

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

Можно использовать как тип string, так и отдельный тип — char?
Или ->
Нужно использовать специальный тип — symbol?
Или может ->
Тот же, что и для строк — string?
Или ->
Можно использовать как тип string, так и отдельный тип — symbol?

Голосование за лучший ответ

В JS динамическая типизация. char равен string, разницы в этом языке нет. Тип symbol — это совершенно другой и создан для других целей. И Вам пока не нужно понимать где он применяется до полного понимания примитивных типов в JS

базовые типы
Обработка текста — String, RegExp // Объекты для манипулирования текстом.

Числа и даты — Number Math Date // Объекты, имеющие дело с числами, датами и математическими вычислениями.

Массивоподобные объекты. Array

Типы и структуры данных 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 (en-US) (в 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 (en-US) и 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) (добавляет элемент в конец массива) и т. д. Всё это делает массив идеальным кандидатом для представления списков и перечислений.

    Типизированные массивы являются подобными массивам представлениями наборов бинарных данных и предлагают множество методов, семантика которых аналогична аналогам массива. «Типизированный массив» это общий термин для ряда структур данных, включая Int8Array , Float32Array и т.д. Подробнее о них можно узнать в руководстве о типизированных массивах. Типизированные массивы часто используются вместе с ArrayBuffer и DataView .

    Коллекции: 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 18 дек. 2023 г. by MDN contributors.

    Your blueprint for a better internet.

    Типы данных в JavaScript

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

      boolean — логический тип данных, который принимает значения true иди false

    let val = false; val = true; 
    let val = 50; val = 3.14159; val = -200; 

    Этот тип представляет из себя число двойной точности, подробнее о нём можно прочитать здесь. Ноль в JavaScript имеет два представления: -0 и +0 . («0» это синоним +0). На практике это имеет малозаметный эффект. Например, выражение +0 === -0 является истинным. А также есть специальные значения, которые по сути не являются числами, но принадлежат к числовому типу данных: Infinity (бесконечность) и NaN (Not a Number — “Не Число”)

    let inf = Infinity; // прямое присвоение бесконечности inf = 57 / 0; // Infinity получится при делении на ноль inf = -Infinity; // есть отрицательная бесконечность inf = 57 / -0; // -Infinity let notNumber = NaN; notNumber = "строка" * 5; // При ошибке вычисления вернёт NaN 

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

    let value = ? console.log(i * i) // 0 console.log(i + 1) // 1 console.log(i - 1) // -1 console.log(i / i) // 1 
    let str = "Это строка"; console.log(str[0]); // Э - первый символ строки console.log(str.length); // 10 console.log(str[str.length - 1]); // а - последний символ строки str = 'А это "строка в двойных кавычках" внутри строки'; 

    Также соединения строк (конкатенации) можно использовать оператор + или метод String.concat() . Также для составления строк с использованием значений переменных удобно применять шаблонизацию через обратные кавычки — `строка с переменной $`

    let name = "Василий"; let helloMsg = "Привет, " + name + "!"; // Привет, Василий! let newHelloMsg = name.concat(", здравствуйте. ", "Удачного дня!"); // Василий, здравствуйте. Удачного дня! //Для помещения значений переменных в шаблон используется конструкция $ helloMsg = `Привет, $name>`; // Привет, Василий! 
    let sym1 = Symbol(); let sym2 = Symbol("foo"); 
    let data = null; 
    let data; console.log(data); // undefined 

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

    Оператор typeof возвращает строку, указывающую тип операнда. Синтаксис вызова этого оператора: typeof operand . Например:

    // Числа console.log(typeof 42); // "number" console.log(typeof Infinity); // "number" console.log(typeof NaN); // "number", несмотря на то, что смысл этого значения "Not-A-Number" (не число) // Строки console.log(typeof "строка"); // "string" let name = "Василий"; console.log(typeof `Привет, $name>`); // "string" // Булевы значения console.log(typeof true); // "boolean" console.log(typeof false); // "boolean" // Символы console.log(typeof Symbol()); // "symbol" // undefined let declaredButUndefinedVariable; console.log(typeof declaredButUndefinedVariable); // "undefined"; // Объекты console.log(typeof  a: 1 >); // "object" console.log(typeof [1, 2, 3]); // такая структура данных, как массив, тоже "object" 

    Но есть два значения, для которых оператор typeof не совсем корректно отражает их тип:

      Значение null , для него typeof возвращает тип “object”, что является официально признанной ошибкой в языке, которая сохраняется для совместимости. На самом деле это не объект, а отдельный тип данных null .

    // null console.log(typeof null); // "object" 
    // function console.log(typeof function() <>); // "function" 

    Примитивные и ссылочные типы данных

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

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

    // Примитивный тип number let num = 5; // Функция для прибавления двойки к примитиву function addTwo(num)  num = num + 2; > // Вызов функции addTwo(num); console.log(num); // 5 

    Что происходит после вызова этой функций?

    В первую функцию addTwo в качестве параметра передаётся значение переменной num из глобальной области видимости, то есть 5 . Таким образом Запись Окружения этой функции после вызова будет выглядеть так:

    let num = 5; function addTwo(num)  // на этапе создания контекста - , где num, это локальная переменная функции addTwo num = num + 2; // на этапе выполнения контекста, эта строка изменит запись на > addTwo(num); console.log(num); // 5 

    Но что же и этом произойдет со значением переменной num из глобальной области видимости? В действительности её значение останется таким же, как и было до вызова функции addTwo , так как в неё просто было скопировано значение этой переменной. И все манипуляции уже производились над другой переменной из области видимости функции addTwo . В текущей ей реализации она просто производит операцию над локальной переменной и не возвращает никакого определенного значения (а точнее она вернёт undefined ).

    Если переписать эту функцию, чтобы она возвращала новое значение локальной переменной num и потом присвоить это значение обратно уже в глобальную переменную num , то только в таком случае её значение поменяется:

    let num = 5; function addTwo(num)  // на этапе создания контекста - num = num + 2; // на этапе выполнения контекста, эта строка изменит запись на return num; // вернуть результатом функции новое значение > num = addTwo(num); // присвоить результат функции как новое значение переменной console.log(num); // 7 

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

    Теперь рассмотрим как передаются значения объектов:

    // Ссылочный тип object let obj =  key: 5 >; // Функция для прибавления двойки к свойству объекта function addTwoObj(obj)  obj.key = obj.key + 2; > // Вызов функции addTwoObj(obj); console.log(obj.key); // 7 

    Почему в данном случае свойство объекта изменилось, хотя никаких дополнительных действий по возврату нового значения и его присваивания не происходило?

    В этом случае важно понимать, что переменная содержит не сам объект, а грубо говоря указатель (ссылку) на то место в памяти, где этот объект хранится. Поэтому параметром в функцию будет передаваться именно это ссылка объект и Запись Окружения этой функции после вызова будет выглядеть так:

    let obj =  key: 5 >; function addTwoObj(obj)  // на этапе создания контекста - >, здесь переменная obj опять же является уже локальной переменной функции addTwoObj obj.key = obj.key + 2; // на этапе выполнения контекста, эта строка сначала по переданной ссылке в obj найдет сам объект < key: 5 >изменит свойство key самого объекта, а не его копии. Запись Окружения станет > > addTwoObj(obj); // переменная obj хранит в себе ссылку а объект < key: 5 >, поэтому параметром передаётся именно эта ссылка console.log(obj.key); // Был изменен сам объект, который был передан по ссылке, поэтому значение его свойства будет 7 

    А что выведется в консоль, если изменить локальную переменную obj ?

    let obj =  key: 5 >; function addTwoObj(obj)  obj.key = obj.key + 2; obj =  num: 6 >; // присвоить другой объект obj = null; // или же вообще присвоить нулевое значение > addTwoObj(obj); console.log(obj.key); 

    Здесь в консоли снова выведется 7 . Так как в функции addTwoObj переменная obj является локальной и затеняет одноименную глобальную переменную, то присваивания ей в функции новых значений никак не отразится на глобальной переменной obj . Это лишь приведет к перезаписи переданной ссылки на объект < key: 5 >новыми значениями.

    let obj =  key: 5 >; function addTwoObj(obj)  // на этапе создания контекста - >, здесь переменная obj опять же является уже локальной переменной функции addTwoObj obj.key = obj.key + 2; // на этапе выполнения контекста, эта строка сначала по переданной ссылке в obj найдет сам объект < key: 5 >изменит свойство key самого объекта, а не его копии. Запись Окружения станет > obj =  num: 6 >; // после выполнения этой строки измениться лишь значение локальной переменной в Записи Окружения: > obj = null; // а здесь вообще в локальную переменную запишется значение null примитивного типа > addTwoObj(obj); // переменная obj хранит в себе ссылку а объект < key: 5 >, поэтому параметром передаётся именно эта ссылка console.log(obj.key); // Был изменен сам объект, который был передан по ссылке, поэтому значение его свойства будет 7 

    Обертки примитивных типов в JavaScript

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

    • String для string примитива.
    • Number для number примитива.
    • Boolean для boolean примитива.
    • Symbol для symbol примитива.

    Что происходит когда вызывается какой-либо метод у примитивного типа данных, например:

    let char = "текст".charAt(1); // е 

    Так как у примитивного типа строки нет своих методов, то сначала создаётся его копия и неявно оборачивается в его объектный аналог с помощью конструктора new String(something) . И уже в рамках этого объекта существует набор различных встроенных методов, дин из них — charAt() , который возвращает символ строки по указанной позиции. После вызова метода возвращается его результат и эта объектная обёртка уничтожается. Поэтому сам вызов метода никак не влияет на изначальное значение примитива, а только возвращает вычисленное значение.

    Явно этот код можно записать так:

    let char = new String("текст").charAt(1); // "е" 

    И именно поэтому вызов следующих методов будет лишь возвращать новые значения и никак не повлияет на исходную переменную str :

    let str = "текст"; let upper = str.toUpperCase(); let substr = str.substring(0, 3); console.log(upper); // "ТЕКСТ" console.log(substr); // "тек" console.log(str); // "текст" 

    У каждой такой объектной обертки есть метод valueOf() , который возвращает соответствующее значение примитивного типа. Например:

    var numObj = new Number(10); console.log(typeof numObj); // object var num = numObj.valueOf(); console.log(num); // 10 console.log(typeof num); // number 

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

    Дата изменения: February 26, 2023

    Поделиться

    Обнаружили ошибку или хотите добавить что-то своё в документацию? Отредактируйте эту страницу на GitHub!

    Восемь типов данных, 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 , возвращая его в виде строки.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *