🔢 Типы, сравнение и приведение
На разминке по языку на собеседовании по Node.js спрашивают, что вернёт typeof null, чем == отличается от === и почему 0.1 + 0.2 не равно 0.3. Они кажутся детскими, но по ним видно, понимает ли кандидат, как JavaScript хранит значения и когда сам меняет их тип. На работе те же правила всплывают в багах: порт из переменной окружения оказался строкой, id из Postgres пришёл строкой, а сумма заказа потеряла копейку
🧠 Как это устроено
Восемь типов и одно исключение
В JavaScript семь примитивов и объекты. Примитивы: undefined, null, boolean, number, bigint, string и symbol. Всё остальное, включая массивы, функции, Date и Map, — объекты
Примитив неизменяем. str.toUpperCase() не меняет строку, а возвращает новую. Объект живёт в куче, и в переменной лежит ссылка на него
typeof отвечает почти честно:
typeof undefined // 'undefined'
typeof 1n // 'bigint'
typeof function(){} // 'function'
typeof [] // 'object', массив проверяют через Array.isArray
typeof null // 'object'typeof null === 'object' — ошибка первой реализации языка. Значения хранились как тег типа плюс само значение, у объектов тег был 0, а null был нулевым указателем, то есть тоже с тегом 0. Исправление предлагали в стандарт, но отклонили, чтобы не сломать старый код. Поэтому null проверяют прямо: value === null
Передача в функцию
Всё в JavaScript передаётся по значению. Для объекта значение — это ссылка, поэтому функция может поменять поля объекта, но не может подменить сам объект у вызывающего:
function f(o, n) {
o.x = 2 // меняем объект по ссылке, это видно снаружи
n = 5 // локальная копия числа
o = { x: 3 } // локальная переменная теперь смотрит на новый объект
}
const obj = { x: 1 }
let num = 1
f(obj, num)
console.log(obj, num) // { x: 2 } 1На собеседовании ответ «объекты передаются по ссылке» засчитают, но сильнее звучит «по значению, и это значение — ссылка». Именно поэтому присваивание o = { x: 3 } наружу не протекает
Отсюда же вопрос про копирование. Spread { ...obj } копирует только верхний уровень. Глубокую копию делает structuredClone, он есть в Node с 17-й версии и сохраняет Date, Map и циклические ссылки. Старый приём JSON.parse(JSON.stringify(x)) превращает Date в строку и теряет undefined
Три сравнения
| Оператор | Приводит типы | NaN и NaN | 0 и -0 |
|---|---|---|---|
== | да | не равны | равны |
=== | нет | не равны | равны |
Object.is | нет | равны | не равны |
Есть и четвёртое, внутреннее, SameValueZero: как Object.is, но 0 и -0 равны. По нему работают includes и ключи в Map и Set. Поэтому [NaN].includes(NaN) вернёт true, а [NaN].indexOf(NaN) вернёт -1: indexOf сравнивает через ===
Нестрогое == сначала приводит операнды к общему типу. Правила длинные, но на практике хватает четырёх:
nullиundefinedравны друг другу и больше ничему.null == 0—false- Если сравниваются строка и число, строка превращается в число.
'' == 0—true, потому что пустая строка даёт0 booleanвсегда превращается в число раньше всего остального.'0' == false— это'0' == 0, то естьtrue- Объект превращается в примитив через
Symbol.toPrimitive,valueOfилиtoString.[]становится'', а''становится0
Из этих правил собирается любимая задача [] == ![]. Справа ![] — это false, потому что массив истинный. Дальше [] == false → [] == 0 → '' == 0 → 0 == 0, итог true
Единственное место, где == пишут сознательно, — value == null. Оно ловит и null, и undefined одной проверкой. В остальном коде ===, а ESLint правилом eqeqeq это закрепляет
Неявное приведение в операторах
+ складывает числа, но если хоть один операнд строка, склеивает строки. Остальные арифметические операторы всегда приводят к числу:
'5' - 2 // 3
'5' + 2 // '52'
1 + true // 2
[] + {} // '[object Object]'
+' 42 ' // 42, пробелы по краям отбрасываются
Number('') // 0
Number('12px') // NaN
parseInt('12px') // 12, читает цифры до первого мусораNumber и parseInt ведут себя по-разному, и это стоит знать для разбора входных данных. Number требует, чтобы вся строка была числом, а пустую строку молча превращает в 0. parseInt читает начало строки и отбрасывает хвост. Для параметров из запроса и конфига надёжнее Number(x) с проверкой Number.isInteger, чем parseInt
Ложные значения и ??
Ложных значений восемь: false, 0, -0, 0n, '', null, undefined и NaN. Всё остальное истинно, включая 'false', '0', [] и {}
Отсюда разница между || и ??. || берёт правый операнд для любого ложного значения, ?? — только для null и undefined:
const config = { retries: 0 }
config.retries || 3 // 3, ноль потерялся
config.retries ?? 3 // 0Числа: double, NaN и BigInt
number — это 64-битное число с плавающей точкой по IEEE 754. Целые в нём точны только до Number.MAX_SAFE_INTEGER, то есть до 2⁵³ − 1 = 9 007 199 254 740 991. Дальше начинаются потери: 2 ** 53 + 1 выведет 9007199254740992
Десятичные дроби в двоичном виде хранятся с округлением, поэтому 0.1 + 0.2 даёт 0.30000000000000004. Так устроен сам формат: Python, Go и Java на double считают так же
NaN не равен ничему, даже себе. Проверяют его через Number.isNaN(x). Глобальный isNaN сначала приводит аргумент к числу, поэтому isNaN('abc') вернёт true, хотя 'abc' — строка, а не NaN
BigInt хранит целые любой длины: 9007199254740993n + 1n вернёт 9007199254740994n без потерь. Смешивать его с number нельзя, 1n + 1 бросит TypeError: Cannot mix BigInt and other types. И JSON.stringify его не умеет: Do not know how to serialize a BigInt
var, let, const и hoisting
Все три объявления поднимаются (hoisting): движок узнаёт о переменной до того, как дойдёт до строки с ней. Разница в том, что лежит в переменной до этой строки
varсразу получаетundefinedи видна во всей функции.console.log(v); var v = 1выведетundefinedletиconstвидны только в своём блоке{ }и до объявления находятся во временной мёртвой зоне (TDZ). Обращение к ним бросаетReferenceError: Cannot access 'x' before initialization. Дажеtypeof xв TDZ бросает ошибку, хотя для необъявленной переменной вернул бы'undefined'
const запрещает переприсвоить переменную, но не делает объект неизменяемым. const arr = [1]; arr.push(2) работает. Object.freeze запрещает менять поля, но только на верхнем уровне: вложенный объект внутри замороженного остаётся изменяемым
В современном коде var не пишут. Правило простое: по умолчанию const, let там, где значение меняется. Как блочная область видимости let меняет поведение замыканий в цикле, видно на странице про замыкания
🛠️ На практике
Числа из окружения и запроса
Всё, что приходит в процесс снаружи, — строки: process.env, query-параметры, заголовки, части URL. process.env.PORT всегда строка или undefined, и process.env.PORT + 1 даст '30001'
function intFromEnv(name, fallback) {
const raw = process.env[name]
if (raw === undefined || raw.trim() === '') return fallback
const n = Number(raw)
if (!Number.isInteger(n)) throw new Error(`${name} должен быть целым числом, сейчас "${raw}"`)
return n
}Проверка на пустую строку нужна, потому что Number('') вернёт 0, и сервис молча стартует на нулевом порту. В реальном проекте такую проверку берёт на себя схема конфига, об этом на странице про конфиг и готовность к проду
id и деньги из Postgres
Драйвер pg по умолчанию отдаёт bigint (int8) строкой. Автор драйвера объясняет это прямо: 64-битное целое не помещается в number без потерь, и драйвер не хочет тихо портить данные. То же с numeric, в котором обычно хранят деньги. Поэтому row.id === 42 будет false, а row.total + row.fee склеит две строки
Что с этим делать:
- id оставить строкой. С ним не считают, его сравнивают и передают дальше, а строка в JSON не теряет точность
COUNT(*)тоже приходит строкой. Если значение точно меньше 2⁵³, приведи его в запросе (count(*)::int) или черезNumberв коде- деньги хранить целыми в копейках (
bigint) илиnumeric, а считать вBigIntили через библиотеку десятичной арифметики. Сложение рублей вnumberрано или поздно даст0.30000000000000004в чеке
⚠️ Где ошибаются
- Проверяют объект через
typeof x === 'object'. Под это условие попадаетnull, и следующееx.idпадает сTypeError. Нужноx !== null && typeof x === 'object' - Пишут
value || defaultдля чисел и строк.0,''иfalse— нормальные значения настройки, а||их выбрасывает. Для значений по умолчанию нужен?? - Сравнивают id из базы с числом.
user.id === req.params.idсравнит две строки и сработает, аuser.id === 42— нет. Договорись, что id в коде всегда строка, и приводи на границе - Сортируют числа через
sort()без функции. По умолчанию элементы сравниваются как строки:[10, 9, 1].sort()вернёт[1, 10, 9]. Нужноsort((a, b) => a - b) - Ищут
NaNчерез===илиindexOf. Оба сравнивают строго иNaNне находят. РаботаютNumber.isNaNиincludes
🎯 Вопросы с собеседований
Какие типы данных есть в JavaScript?
Семь примитивов: undefined, null, boolean, number, bigint, string, symbol, и объекты. Массивы, функции, даты и Map — разновидности объектов. Примитивы неизменяемы и сравниваются по значению, объекты сравниваются по ссылке: {} === {} даёт false
Почему typeof null возвращает 'object'?
Это ошибка первой реализации языка. Значение хранилось как тег типа и данные, у объектов тег был 0, а null был нулевым указателем и получил тот же тег. Исправление предлагали в стандарт, но отказались, потому что сломалось бы много существующего кода. Поэтому null проверяют через === null
Чем == отличается от ===?
=== сравнивает без приведения типов: разные типы сразу не равны. == сначала приводит операнды к общему типу, обычно к числу, и только потом сравнивает, отсюда '' == 0 и '0' == false. В коде используют ===. Исключение — x == null, которое одной проверкой ловит null и undefined
Чему равно [] == ![] и почему?
true. Сначала вычисляется ![]: массив истинный, значит false. Потом [] == false: булево приводится к числу 0, массив приводится к примитиву через toString и становится '', пустая строка становится 0. Получается 0 == 0
Как проверить, что значение — NaN?
Через Number.isNaN(x). NaN не равен даже себе, поэтому x === NaN всегда false. Глобальный isNaN сначала приводит аргумент к числу и вернёт true для любой нечисловой строки. Ещё Object.is(x, NaN) и [NaN].includes(x) считают NaN равным себе
Почему 0.1 + 0.2 !== 0.3 и как считать деньги?
number — двоичное число с плавающей точкой по IEEE 754, и 0.1 в двоичном виде точно не записывается, отсюда 0.30000000000000004. Деньги хранят целыми в копейках или в numeric в базе. Считают целыми числами, BigInt или библиотекой десятичной арифметики, а дробные значения показывают только при выводе
Зачем нужен BigInt?
Для целых больше Number.MAX_SAFE_INTEGER, это 2⁵³ − 1. Дальше number теряет точность: 2 ** 53 + 1 выводится как 2 ** 53. На бэкенде это bigint id из базы, суммы в копейках, внешние идентификаторы. Ограничения: его нельзя смешивать с number в арифметике, и JSON.stringify бросает на нём TypeError, поэтому в API такие значения обычно отдают строкой
Объекты в JavaScript передаются по ссылке или по значению?
По значению, но для объекта это значение — ссылка. Функция может изменить поля переданного объекта, и это будет видно снаружи. Присвоить параметру новый объект можно, но вызывающий код этого не увидит. Если нужно не трогать исходный объект, его копируют: { ...obj } для верхнего уровня, structuredClone для глубокой копии
Чем отличаются var, let и const?
var видна во всей функции и до объявления равна undefined. let и const видны только в блоке и до объявления находятся во временной мёртвой зоне: обращение бросает ReferenceError. const нельзя переприсвоить, но объект в ней менять можно. Объявить let с тем же именем в том же блоке нельзя, это SyntaxError
Что такое hoisting и TDZ?
Hoisting — движок регистрирует объявления до выполнения кода блока. Для var переменная сразу получает undefined, функции-объявления поднимаются целиком и их можно вызвать раньше строки с ними. let, const и class тоже известны движку заранее, но до своей строки находятся во временной мёртвой зоне. Зона зависит от порядка выполнения, а не от места в тексте: функция, которая читает let, может быть объявлена выше, если вызвана после инициализации
📚 Что почитать
- MDN: Equality comparisons and sameness — все четыре сравнения в одной таблице и где какое используется
- MDN: typeof — откуда взялся
typeof nullи какtypeofведёт себя в TDZ - MDN: let — временная мёртвая зона с примерами и правила повторного объявления
- README pg-types — почему
pgотдаётbigintстрокой и как поменять парсер дляint8