К содержимому
Войти

Node.js Road Map

🔢 Типы, сравнение и приведение

На разминке по языку на собеседовании по 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 и NaN0 и -0
==дане равныравны
===нетне равныравны
Object.isнетравныне равны

Есть и четвёртое, внутреннее, SameValueZero: как Object.is, но 0 и -0 равны. По нему работают includes и ключи в Map и Set. Поэтому [NaN].includes(NaN) вернёт true, а [NaN].indexOf(NaN) вернёт -1: indexOf сравнивает через ===

Нестрогое == сначала приводит операнды к общему типу. Правила длинные, но на практике хватает четырёх:

  1. null и undefined равны друг другу и больше ничему. null == 0 — false
  2. Если сравниваются строка и число, строка превращается в число. '' == 0 — true, потому что пустая строка даёт 0
  3. boolean всегда превращается в число раньше всего остального. '0' == false — это '0' == 0, то есть true
  4. Объект превращается в примитив через 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 выведет undefined
  • let и 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