ФАЗА 33. JAVASCRIPT Типы

Примитивы, ссылки и настоящий typeof

undefined · null · NaN

Семь примитивов и объекты определяют поведение присваивания, проверки типов и вызова методов.

1. Семь примитивов отделяются от объектов

1 / 5

string, number, bigint, boolean, undefined, symbol и null являются примитивами. Массивы, функции и обычные объекты образуют вторую группу.

  • Функция является вызываемым объектом.
  • Массив не имеет отдельного typeof.
  • BigInt не смешивается с number автоматически.
Типы JavaScriptПримитивыОбъектыФункции и массивы

2. undefined и null означают разное

2 / 5

undefined обычно означает отсутствие присвоенного значения, null является явным маркером отсутствия объекта.

  • Необъявленное свойство даёт undefined.
  • null присваивают намеренно.
  • Строгая проверка различает их.
undefined: значения нетnull: явно пусто

3. number объединяет целые и дробные

3 / 5

Числа используют IEEE 754, NaN обозначает нечисловой результат, а точность больших целых ограничена.

  • NaN не равен самому себе.
  • Number.isNaN проверяет без приведения.
  • BigInt нужен для больших целых.
numberNaN и бесконечностьBigInt для целых

4. Присваивание объекта копирует ссылку

4 / 5

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

  • Сравнение объектов сравнивает ссылки.
  • Новый литерал создаёт другой объект.
  • Копирование структуры требует отдельной операции.
a и b: один объектПримитив: независимые значения

5. Метод примитива использует временную упаковку

5 / 5

Строка или число допускают обращение к методу через объект-обёртку прототипа, сам примитив при этом не становится сохранённым объектом.

  • Метод находится в прототипе.
  • Явные обёртки обычно не нужны.
  • typeof null остаётся историческим object.
ПримитивДоступ через прототипРезультат метода

Типы в JavaScript: примитивы, объекты и typeof

← назад к разделу

В JavaScript «у переменных нет типов — типы есть у значений». Переменная может хранить сегодня строку, завтра число, и это законно. Поэтому понимать систему типов здесь важнее, чем в строгих языках: она не проверяется компилятором, а работает прямо во время выполнения — и удивляет тех, кто её не знает.

Семь примитивов и всё остальное

Примитивные типы: string, number, boolean, undefined, null, symbol, bigint. Всё остальное — объекты: обычные объекты, массивы, функции, даты, регулярные выражения.

typeof "hi";        // "string"
typeof 42;          // "number"
typeof true;        // "boolean"
typeof undefined;   // "undefined"
typeof Symbol();    // "symbol"
typeof 10n;         // "bigint"

typeof {};          // "object"
typeof [];          // "object"  — массив тоже объект!
typeof function(){} // "function" — особый ответ для функций
typeof null;        // "object"  — знаменитый баг языка

Два ответа typeof требуют комментария. typeof null === "object" — историческая ошибка первой реализации, которую нельзя исправить, не сломав интернет: проверяйте null сравнением x === null. А "function" — любезность: функции формально объекты, но typeof выделяет их отдельно.

Массив от объекта typeof не отличит — для этого есть Array.isArray():

Array.isArray([]);  // true
Array.isArray({});  // false

undefined и null: два вида «ничего»

В языке два «пустых» значения, и по конвенции они означают разное:

  • undefined — «значения ещё не было»: необъявленное свойство, параметр без аргумента, функция без return.
  • null — «значение намеренно пустое»: его присваивают явно, обозначая осознанное отсутствие.
let user;
user;              // undefined — не присвоили
const found = null; // null — искали и осознанно не нашли

Практическое следствие: если в данных вы видите undefined — скорее всего, кто-то забыл присвоить или опечатался в имени свойства; null — кто-то положил пустоту специально. Проверка «нет ни того ни другого» одной строкой: x == null — редкий случай, когда нестрогое сравнение осознанно полезно.

number: один тип на всё и NaN

В JavaScript нет отдельных целых и дробных — только number (64-битный float). Отсюда две классики:

0.1 + 0.2 === 0.3;        // false! 0.30000000000000004
Number.MAX_SAFE_INTEGER;  // 9007199254740991 — дальше целые «врут»

Дробные деньги не считают в number «в лоб» — считают в копейках или через строковые библиотеки; для гигантских целых есть bigint.

NaN («not a number») — результат бессмысленной числовой операции. Его коварство: NaN — единственное значение, не равное самому себе:

NaN === NaN;        // false
Number.isNaN(NaN);  // true — правильная проверка

Если сравнение x === x даёт false — перед вами NaN. Это не шутка, а реальный приём из старого кода.

Значение против ссылки

Главная развилка поведения: примитивы копируются по значению, объекты — по ссылке.

let a = 1;
let b = a;
b = 2;
a; // 1 — копия независима

const x = { n: 1 };
const y = x;
y.n = 2;
x.n; // 2! — x и y указывают на ОДИН объект

Это фундамент, на котором стоят и копирование объектов, и правила изменения состояния в React. Пока держите в голове само правило: присваивание объекта не создаёт новый объект — только вторую ссылку на тот же.

Упаковка: почему у строки есть методы

Строка — примитив, но "hi".toUpperCase() работает. Как? При обращении к свойству примитива движок на мгновение оборачивает его в объект (String, Number, Boolean), вызывает метод и выбрасывает обёртку. Отсюда правило: обёртки существуют, но создавать их руками (new String("hi")) не нужно никогда — вы получите объект со всеми сюрпризами объектного поведения:

typeof new String("hi"); // "object", не "string"
new Boolean(false) ? 1 : 2; // 1! объект всегда truthy

Коротко

  • Типы у значений, не у переменных. Семь примитивов, всё остальное — объекты (массивы и функции тоже).
  • typeof null === "object" — баг языка; null проверяют через === null, массивы — через Array.isArray().
  • undefined — «не присвоили», null — «пусто намеренно». x == null ловит оба.
  • Один числовой тип: 0.1 + 0.2 !== 0.3, деньги — в копейках. NaN не равен сам себе, проверка — Number.isNaN().
  • Примитивы копируются по значению, объекты — по ссылке. Это причина половины «мистических» багов.
  • Обёртки примитивов работают автоматически; new String() руками — не надо.

Что почитать дальше