Как V8 представляет значение

Одно слово, чтобы хранить любое значение

Переменная, элемент массива, слот свойства объекта, регистр внутри интерпретатора — всё это ровно одно машинное слово шириной, 64 бита на современном процессоре. Эта однородность не случайна; именно она делает движок простым и быстрым. Загрузка элемента массива — это одна и та же инструкция, будь элемент числом или объектом, потому что загружаемое — всегда одно слово. Движку никогда не нужно спрашивать «насколько велико это значение», прежде чем его передвигать.

Но значения JavaScript в принципе не одного размера. Малое целое умещается в слово тривиально. Объект, строка, замыкание — они произвольно велики. Поэтому V8 применяет классический системный трюк: слово — это tagged union (тегированное объединение). Оно хранит либо значение прямо в себе, либо указатель на то, где живёт настоящее значение, а тег говорит, какая трактовка применима.

Случаев ровно два:

• Smi («Small Integer», малое целое) — малое знаковое целое, хранимое прямо в слове. Никакого объекта в куче нет; биты слова и есть число. Чтение бесплатно.
• Указатель на HeapObject — слово содержит адрес объекта в куче. Настоящее значение (поля объекта, символы строки, 64 бита double) живёт по этому адресу. Чтение стоит разыменования.

Тег-бит: как движок их различает

Трюк в выравнивании. Каждый HeapObject размещается по чётному адресу (выровнен как минимум на 2 байта, на практике на 4 или 8), поэтому настоящий указатель всегда имеет младший бит, равный 0. V8 этим пользуется: он ставит младший бит указателя в 1, помечая «это слово — указатель», и оставляет младший бит 0, помечая «это слово — Smi». (Точную раскладку битов мы увидим в следующих двух уроках — здесь важно, что одного бита достаточно для различения.)

Поэтому каждый раз, глядя на слово-значение, движок первым делом делает один битовый тест по младшему биту:

// Концептуально любое обращение к значению начинается с этой ветки:
if ((word & 1) === 0) {
  // Smi: целое закодировано в старших битах — используем напрямую
} else {
  // HeapObject: сбрасываем тег и разыменовываем, чтобы дойти до объекта
}

Эта ветка — одна инструкция процессора. Это входная плата за динамическую типизацию, и V8 два десятилетия делал её дешёвой и предсказуемой.

Все HeapObject начинаются с указателя на Map

Когда слово является указателем, на что оно указывает? Каждый HeapObject — объект, массив, строка, функция, упакованное число — начинает свою раскладку памяти с одного слова: указателя на свой Map. Map — это термин V8 для hidden class: он описывает, какого вида этот HeapObject и, для обычных объектов, раскладку его свойств (какие имена живут по каким смещениям).

Вот почему движок может разыменовать любой указатель на HeapObject и сразу узнать его тип и форму: ответ всегда по смещению 0.

Раскладка памяти HeapObject:
  [ Map pointer    ]  <- смещение 0: «кто я и какова моя раскладка»
  [ поле / данные  ]  <- следующее слово: зависит от вида
  [ поле / данные  ]
  ...

Map — это стержень всей истории про производительность; hidden classes, inline caches и деопт держатся на нём. Map мы подробно разбираем в юните про hidden classes; здесь просто зафиксируйте структурный факт: значение — это слово; если его тег говорит «указатель», оно указывает на HeapObject; а первое слово HeapObject — это его Map.

Oddballs: true, false, null, undefined и hole

Так где же живут true, false, null и undefined? Они не Smi (это не целые) и не «объекты» в смысле JS. V8 представляет их как Oddballs — особые синглтонные HeapObject. В целом изоляте существует ровно один Oddball undefined, один null, один true, один false. Переменная, хранящая undefined, хранит указатель на этот единственный общий Oddball.

Есть и скрытый Oddball, который вы никогда не видите напрямую: hole (TheHole). V8 использует его как сторожевое значение, помечая пустой слот массива или неинициализированную привязку let (временная мёртвая зона — это буквально «в слоте всё ещё лежит hole»). Чтение hole и есть то, что вызывает ReferenceError при доступе в TDZ или проверку на дырку в разреженном массиве.