Все о значениях в языке JavaScript: от типов до глубокого копирования

Расширенные примеры работы со значениями

Упаковка примитивов (boxing)

При обращении к методу или свойству примитива (кроме null и undefined) JavaScript временно оборачивает его в объект-обёртку (String, Number, Boolean), после чего обёртка уничтожается. Это позволяет, например, вызывать 'text'.toUpperCase(), но не сохранять свойства на примитиве.

let primitiveString = 'Hello';
primitiveString.custom = 'world';
console.log(primitiveString.custom); // undefined (временная обёртка)

let wrapped = new String('Hello');
wrapped.custom = 'world';
console.log(wrapped.custom); // 'world' (объект сохраняет свойство)

undefined
world

Передача по ссылке: изменение внутри функции

function changeObj(obj) {
  obj.name = 'changed';
}
let myObj = { name: 'original' };
changeObj(myObj);
console.log(myObj.name); // 'changed'

function replaceObj(obj) {
  obj = { name: 'newObject' }; // параметр заменён на новую ссылку
}
let anotherObj = { name: 'old' };
replaceObj(anotherObj);
console.log(anotherObj.name); // 'old' (исходный объект не изменился)

changed
old

Значения BigInt и Symbol

let big = 1234567890123456789012345678901234567890n;
console.log(typeof big); // 'bigint'

let sym = Symbol('id');
let sym2 = Symbol('id');
console.log(sym == sym2); // false (каждый Symbol уникален)

// Типичная ошибка: BigInt нельзя смешивать с number в арифметике
// console.log(1n + 1); // TypeError

bigint
false

Проверка на NaN: isNaN vs Number.isNaN

console.log(isNaN('текст'));        // true ('текст' приводится к NaN)
console.log(Number.isNaN('текст')); // false (не выполняет преобразование)
console.log(Number.isNaN(NaN));     // true

// Ещё одна особенность: NaN не равен самому себе
console.log(NaN === NaN); // false

true
false
true
false

Преобразование в булевый тип (falsy значения)

// falsy: 0, '', null, undefined, NaN, false
function checkTruthy(value) {
  if (value) {
    console.log('truthy');
  } else {
    console.log('falsy');
  }
}
checkTruthy(0);           // falsy
checkTruthy(' ');         // truthy (непустая строка)
checkTruthy([]);          // truthy (пустой массив - объект, а объект truthy)
checkTruthy({});          // truthy
checkTruthy(NaN);         // falsy

falsy
truthy
truthy
truthy
falsy

Глубокое сравнение объектов (рекурсивная функция)

function deepEqual(a, b) {
  if (a === b) return true;
  if (a == null || typeof a != 'object' || b == null || typeof b != 'object') return false;
  const keysA = Object.keys(a), keysB = Object.keys(b);
  if (keysA.length !== keysB.length) return false;
  for (let key of keysA) {
    if (!keysB.includes(key)) return false;
    if (!deepEqual(a[key], b[key])) return false;
  }
  return true;
}

const obj1 = { a: { b: 1 } };
const obj2 = { a: { b: 1 } };
const obj3 = { a: { b: 2 } };
console.log(deepEqual(obj1, obj2)); // true
console.log(deepEqual(obj1, obj3)); // false

true
false

Пример с structuredClone и циклическими ссылками

let node = { name: 'root' };
node.self = node; // циклическая ссылка

// JSON.stringify выбросит ошибку
// console.log(JSON.parse(JSON.stringify(node))); // TypeError

// structuredClone справляется
let cloned = structuredClone(node);
console.log(cloned.name); // 'root'
console.log(cloned.self === cloned); // true (циклическая ссылка сохранена)

root
true

Неявное преобразование при сравнении с == (таблица)

console.log('' == 0);        // true
console.log(' ' == 0);       // true (пробел приводится к 0)
console.log('\t' == 0);      // true
console.log([] == 0);        // true (пустой массив -> '' -> 0)
console.log([1] == 1);       // true ([1] -> '1' -> 1)
console.log([1,2] == '1,2');  // true
console.log(null == 0);      // false (null преобразуется только к undefined)
console.log(undefined == null); // true

true
true
true
true
true
true
false
true