Типы данных в языках программирования, в том числе в JavaScript, определяют, какое значение хранится в переменной и какие операции с этим значением можно выполнять.
Какие типы данных есть в JavaScript
Типы данных в JavaScript можно разделить на две группы:
- Примитивные: string, number, bigint, boolean, undefined, null и symbol
Примитив хранит одно значение — число, строку или логическое значение. Само примитивное значение изменить нельзя: при выполнении операции JavaScript создает новое значение.
При присваивании примитивного значения создается его независимая копия:
let first = 10; let second = 20; first = second;
Переменная first получает текущее значение переменной second, то есть 20.
console.log(first);
Вывод:
20
Дальнейшее изменение second не влияет на first, потому что переменные хранят независимые примитивные значения.
second = 30; console.log(first);
Вывод:
20
- Объекты: object
Объект может объединять несколько связанных значений в свойствах. Эти свойства обычно можно добавлять, изменять и удалять.
Например, создадим объект user:
const user = {
name: "Иван",
age: 25
};
Присвоим его полю age новое значение и добавим новое поле city:
user.age = 26; user.city = "Москва";
Получится объект:
const user = {
name: "Иван",
age: 26,
city: "Москва"
};
При присваивании объекта копируется не сам объект, а ссылка на него:
const secondUser = user; secondUser.name = "Петр"; console.log(user.name);
Вывод:
Петр
Примитивные типы
Строки, тип string
Строки хранят последовательности символов: буквы, цифры, пробелы и знаки. Их записывают в одинарных, двойных или обратных кавычках:
const first = 'JavaScript'; const second = "JavaScript"; const third = `JavaScript`;
При этом, даже если строка состоит только из цифр, она остается строкой:
const value = "123"; console.log(typeof value); console.log(value + "4");
Вывод:
string 1234
Строки можно объединять оператором +:
const name = "Иван"; const surname = "Петров"; console.log(name + " " + surname);
Вывод:
Иван Петров
Для вставки значений удобно использовать шаблонные строки. Их записывают в обратных кавычках, а переменные и выражения помещают в ${}:
const name = "Иван";
const age = 25;
console.log(`${name}, ${age} лет`);
Вывод:
Иван, 25 лет
Строки неизменяемы: нельзя заменить символ уже созданного значения. Строковые методы также не меняют исходную строку, а возвращают новую:
const language = "JavaScript"; const result = language.toUpperCase() console.log(language); console.log(result);
Вывод:
JavaScript JAVASCRIPT
Числа, тип number
Тип number используют для целых, дробных и отрицательных чисел:
const count = 10; const price = 99.5; const temperature = -15;
С числами можно выполнять математические операции:
console.log(10 + 5); console.log(10 - 5); console.log(10 * 5); console.log(10 / 5); console.log(10 % 3);
Вывод:
15 5 50 2 1
К типу number также относятся специальные значения:
console.log(1 / 0); console.log(-1 / 0); console.log(0 / 0);
Вывод:
Infinity -Infinity NaN
Infinity и -Infinity означают положительную и отрицательную бесконечности. NaN, или Not a Number, появляется, когда операция не может вернуть корректное числовое значение. Несмотря на название, NaN относится к типу number.
JavaScript хранит числа в 64-битном формате IEEE 754. Поэтому вычисления с дробями могут дать небольшую погрешность:
console.log(0.1 + 0.2);
Получим:
0.30000000000000004
Целые числа можно точно хранить в диапазоне от Number.MIN_SAFE_INTEGER до Number.MAX_SAFE_INTEGER:
console.log(Number.MIN_SAFE_INTEGER); console.log(Number.MAX_SAFE_INTEGER);
Вывод:
-9007199254740991 9007199254740991
Для работы с большими целыми числами используют тип bigint.
Большие целые числа, тип bigint
Тип bigint используют для целых чисел, которые выходят за безопасный диапазон типа number. Значение создают с помощью суффикса n:
const value = 9007199254740992n;
В bigint нельзя записать дробное значение, например:
const value = 10.5n;
Получим ошибку.
Значения number и bigint нельзя напрямую использовать в одной арифметической операции:
console.log(10n + 5);
Выдаст ошибку.
Сначала одно из значений нужно явно преобразовать:
console.log(10n + BigInt(5));
Получим:
15n
При делении bigint дробная часть отбрасывается: bigint всегда остается целым числом, а цифры после запятой не учитываются:
console.log(5n / 2n);
Вывод:
2n
Логические значения, тип boolean
Логический тип boolean содержит только два значения: true — истина и false — ложь. Они появляются в результате сравнения:
console.log(10 > 5); console.log(10 === 5);
Вывод:
true false
Логические значения используют в условиях, например:
const age = 20;
if (age >= 18) {
console.log("Доступ разрешен");
}
Значение undefined
Если переменная undefined, это значит, что значение не было задано или результат отсутствует. Обычно JavaScript присваивает его автоматически.
Например, undefined получает объявленная, но не инициализированная переменная:
let userName; console.log(userName);
Вывод:
undefined
Также undefined возвращается при обращении к отсутствующему свойству объекта:
const user = {
name: "Иван"
};
console.log(user.age);
Вывод:
undefined
Функция возвращает undefined, если в ней нет оператора return:
function showMessage() {
console.log("Привет");
}
const result = showMessage();
console.log(result);
Вывод:
Привет undefined
Некоторые методы также возвращают undefined, если не находят подходящего значения:
const numbers = [1, 2, 3]; const result = numbers.find(number => number > 5); console.log(result);
Вывод:
undefined
Значение null
Значение null означает отсутствие данных, например:
let selectedUser = null;
Это означает, что переменная существует, но подходящий пользователь пока не выбран. От undefined значение null отличается тем, что разработчик обычно присваивает его самостоятельно, чтобы показать, что данные отсутствуют намеренно.
У null есть интересная особенность, что при проверке типа с помощью typeof, возвращается значение «object»:
console.log(typeof null);
Вывод:
object
Сам null при этом не является объектом. Это лишь ошибка первой реализации JavaScript, которую сохранили для совместимости со старым кодом.
Уникальные значения, тип symbol
Тип symbol используют для создания уникальных значений. Символ создают с помощью функции Symbol():
const userId = Symbol("id");
Строка «id» — это описание символа, которое помогает разработчику понять его назначение. Оно отображается в консоли:
console.log(userId);
Вывод:
Symbol(id)
Сам символ — это отдельное уникальное значение, которое JavaScript создает внутри программы. Его описание можно получить через свойство description:
console.log(userId.description);
Вывод:
id
При этом два символа с одинаковым описанием не являются равными:
const firstId = Symbol("id");
const secondId = Symbol("id");
console.log(firstId === secondId);
Получим:
false
Каждый вызов Symbol() создает новое уникальное значение.
Символ можно использовать как ключ свойства объекта:
const internalId = Symbol("id");
const user = {
name: "Иван",
id: "user-123",
[internalId]: 456
};
Символьные свойства не попадают в обычный перебор через Object.keys():
console.log(Object.keys(user));
Вывод:
["name", "id"]
При этом они не являются в полной мере скрытыми или приватными. Получить такое свойство можно, если известен его символ, а все символьные ключи объекта можно найти через Object.getOwnPropertySymbols().
Объекты
Объект объединяет связанные данные в свойствах. Каждое свойство состоит из ключа и значения:
const user = {
name: "Иван",
age: 25,
isAdmin: false
};
Здесь name, age и isAdmin — ключи свойств. JavaScript воспринимает их как строки. Иногда пишут с кавычками: «name», «age», «isAdmin».
Ключами обычно служат строки, а значениями могут быть данные любого типа: числа, строки, логические значения, другие объекты и функции.
К типу object относятся не только обычные объекты, но также массивы, даты, коллекции Map и Set и другие структуры.
Обычные объекты
Объект можно создать с помощью фигурных скобок. Получить значение свойства можно через точку или квадратные скобки:
const user = {
name: "Иван",
age: 25
};
console.log(user.name);
console.log(user["age"]);
Вывод:
Иван 25
Свойства объекта можно изменять и добавлять новые:
user.age = 26; user.city = "Москва";
При присваивании объекта другой переменной обе переменные указывают на один объект:
const secondUser = user; secondUser.name = "Анна"; console.log(user.name);
Вывод:
Анна
Два отдельно созданных объекта не равны, даже если содержат одинаковые свойства:
const first = { name: "Иван" };
const second = { name: "Иван" };
console.log(first === second);
Получим:
| false |
JavaScript сравнивает объекты по ссылкам, а не по содержимому. Результат будет true, только если обе переменные указывают на один и тот же объект.
Массивы
Массив — это специальный объект для хранения упорядоченного набора значений:
const languages = ["JavaScript", "Python", "Java"]; console.log(languages[0]);
Вывод:
JavaScript
Элементы массива располагаются по индексам, начиная с 0.
Функции
Функция — это объект, который можно вызвать для выполнения кода:
function greet() {
console.log("Привет");
}
greet();
Вывод:
Привет
При этом отдельного типа данных function среди восьми основных типов JavaScript нет. Функции относятся к объектам, но их можно вызывать.
Как определить тип значения
Оператор typeof возвращает строку, которая показывает тип переданного значения:
typeof не всегда позволяет точно определить значение. Для некоторых случаев используют отдельные проверки:
- Является ли значение массивом
Array.isArray(value);
- Является ли значение null
value === null;
- Является ли значение NaN
Number.isNaN(value);
- Является ли значение ненулевым объектом
typeof value === "object" && value !== null;
Эта проверка вернет true не только для обычных объектов, но также для массивов, дат и других объектов.
Как JavaScript преобразует типы данных
Как мы уже знаем, JavaScript может преобразовывать значения из одного типа в другой. Приведение типов бывает явным и неявным.
Явное преобразование
При явном преобразовании разработчик сам указывает, в какой тип нужно перевести значение.
- Функция String() преобразует значение в строку:
console.log(String(123)); console.log(String(true));
Вывод:
123 true
Оба результата являются строками, хотя в консоли кавычки обычно не отображаются.
- Функция Number() преобразует значение в число:
console.log(Number("123"));
console.log(Number(true));
console.log(Number(""));
console.log(Number("текст"));
Вывод:
123 1 0 NaN
- Функция Boolean() преобразует значение в true или false:
console.log(Boolean(1));
console.log(Boolean("текст"));
console.log(Boolean(0));
console.log(Boolean(""));
Вывод:
true true false false
Пустые строки и число 0 дают false, а строка с каким-либо содержимым и число 1 — true. Можно отразить возможные преобразования типов в булевые эквиваленты в таблице:
- Функция BigInt() преобразует целое число или строку с целым числом в bigint:
console.log(BigInt(123));
console.log(BigInt("9007199254740992"));
Вывод:
123n 9007199254740992n
Дробное число преобразовать в bigint нельзя:
BigInt(10.5);
Выдаст ошибку. BigInt() принимает целые числовые значения, но не поддерживает дроби.
Неявное преобразование
При неявном преобразовании JavaScript меняет тип значения автоматически во время выполнения операции.
Пример автоматического преобразования числа в строку:
console.log("5" + 1);
Здесь JavaScript сначала преобразует число 1 в строку и объединяет значения.
Вывод:
51
Пример автоматического преобразования строки в число:
console.log("5" - 1);
Здесь строка «5» преобразуется в число 5 и затем происходит вычитание.
Вывод:
4
Пример автоматического преобразования булевого значения в число:
console.log(true + 1);
Вывод:
2
При преобразовании в число значение true становится 1, а false — 0.
Неявное преобразование выполняется и при сравнении через оператор ==:
console.log(5 == "5");
Вывод:
true
Оператор == приводит значения к совместимым типам, а затем сравнивает их. А вот оператор строгого равенства === не преобразует типы:
console.log(5 === «5»);
Вывод:
false
Поэтому чаще используют ===. Результат такого сравнения проще предсказать, поскольку значения разных типов считаются неравными.
Итоги
- В JavaScript есть восемь типов данных: семь примитивных типов и тип object.
- JavaScript использует динамическую типизацию: тип принадлежит значению, а переменная может последовательно хранить значения разных типов.
- Он допускает неявные преобразования, поэтому его обычно относят к языкам со слабой типизацией.
- К примитивам относятся string, number, bigint, boolean, undefined, null и symbol.
- Примитивные значения неизменяемы и при присваивании копируются независимо.
- Тип number подходит для целых и дробных чисел, а bigint — для больших целых значений.
- undefined обычно означает, что значение не было задано, а null используют для намеренного отсутствия данных.
- Символы создают уникальные значения и могут служить ключами свойств объекта.
- Объекты объединяют данные в свойствах. Массивы и функции также относятся к объектам.
- Объекты сравниваются по ссылкам, поэтому два отдельно созданных объекта не равны, даже если содержат одинаковые свойства.
- Для определения типа используют typeof, но массивы, null и NaN требуют отдельных проверок.
- Преобразование типов бывает явным и неявным. Для сравнения значений обычно используют строгое равенство ===, которое не преобразует типы.
