Навигация

Область видимости и hoisting

Почему console.log(x) до var x = 1 печатает undefined, а до let x = 1 падает с ReferenceError? Причина не в том, что движок «переставляет» строки, а в том, как он создаёт биндинги перед выполнением кода. Разберём уровни области видимости, TDZ, устройство лексических окружений и то, как hoisting работает для переменных, функций и классов — на уровне спецификации и на практических примерах.

Содержание

  1. Виды области видимости
  2. var, let, const
  3. Hoisting и Temporal Dead Zone
  4. Лексическое окружение
  5. Function declaration vs function expression
  6. Hoisting классов
  7. Практические примеры: что выведет код
  8. Правила, которые убирают сюрпризы
  9. Ключевые тезисы для интервью
  10. Заключение
  11. Полезные ссылки

Виды области видимости

Область видимости (scope) — это участок кода, в котором имя разрешается в конкретный биндинг. В современном JavaScript можно выделить четыре вида областей:

ОбластьГде возникаетЧто в ней объявляется
Глобальная (script)верхний уровень скриптаvar, function declarations — в объектном окружении; let, const, class — в декларативном
Функциональнаятело функции, параметрыvar, параметры, arguments, function declarations
Блочная{}, if, for, switch, catchlet, const, class; в strict mode — ещё и function declarations
Модульнаятело ES-модулявсе объявления верхнего уровня, включая var; импорты

Глобальная область: два хранилища в одном

Глобальное окружение устроено не так, как остальные. В нём есть объектная часть (свойства globalThis) и декларативная (лексические биндинги):

var globalVar = 'var';
let globalLet = 'let';
function globalFn() {}

console.log(globalThis.globalVar); // 'var'
console.log(globalThis.globalFn);  // [Function: globalFn]
console.log(globalThis.globalLet); // undefined

В глобальном скрипте var и function declaration становятся свойствами глобального объекта. В браузере это window, поэтому к ним можно обратиться как window.globalVar. let, const и class живут в отдельном декларативном окружении и свойствами window не становятся — хотя остаются глобально доступными по имени.

var a = 1;
let b = 2;

console.log(window.a); // 1
console.log(window.b); // undefined

У этого есть практическое следствие: глобальный var нельзя удалить через delete window.a — свойство создаётся как non-configurable, а глобальный let вообще не является свойством объекта.

Модульная область

Каждый ES-модуль выполняется в собственном окружении. Его верхний уровень не является глобальным:

// module.js
var topLevel = 1;

console.log(globalThis.topLevel); // undefined

Поэтому var в модуле не «протекает» в window, а имена модуля не конфликтуют с именами других модулей. Импорты при этом поднимаются и доступны как read-only биндинги.

Функциональная и блочная области

function outer() {
  const functionVar = 'function';

  if (true) {
    const blockVar = 'block';
    console.log(functionVar); // 'function' — видна через внешнее окружение
  }

  console.log(blockVar); // ReferenceError — blockVar живёт только внутри блока
}

Блоком считается любая пара {}: тело if, for, while, switch, catch, а также отдельный блок. var границы блока игнорирует, let/const — нет.

Не стоит путать область видимости с двумя другими механизмами:

  • Цепочка прототипов отвечает за поиск свойств объекта (obj.key), а не имён переменных.
  • this не ищется как обычная переменная: его значение определяется способом вызова функции (стрелочные функции захватывают this лексически).

var, let, const

Разница между этими объявлениями — не только в синтаксисе, но и в том, когда и где движок создаёт биндинг.

var

var имеет функциональную область видимости. Биндинг создаётся при подготовке окружения функции и сразу инициализируется undefined:

function example() {
  console.log(x); // undefined, а не ошибка
  var x = 10;
  console.log(x); // 10
}

Движок не переписывает функцию, но по эффекту это эквивалентно такой схеме:

function example() {
  var x;          // биндинг создан и равен undefined
  console.log(x); // undefined
  x = 10;         // присваивание осталось на месте
  console.log(x); // 10
}

Ключевые свойства var:

  • Одна переменная на функцию. Блоки и циклы не создают новых биндингов:
    var x = 1;
    if (true) {
      var x = 2; // та же самая переменная
    }
    console.log(x); // 2
  • Объявление срабатывает даже в невыполненной ветке. if (false) { var y = 1; } всё равно создаёт y со значением undefined — потому что объявление обрабатывается при входе в функцию, а не при выполнении строки.
  • Повторное объявление разрешено. var x = 1; var x = 2; — валидный код.
  • Присваивание до объявления работает. x = 1; var x; не выбросит ошибку.
  • В глобальном скрипте становится non-configurable свойством globalThis.

let и const

let и const имеют блочную область видимости. Их биндинг тоже создаётся заранее — при входе в блок, — но остаётся неинициализированным до выполнения строки объявления. Это состояние и называется Temporal Dead Zone:

function example() {
  console.log(y); // ReferenceError: Cannot access 'y' before initialization
  let y = 10;
}

Разница между let и const:

  • let разрешает переприсваивание;
  • const запрещает переприсваивание: попытка присвоить новое значение даёт TypeError (в strict и sloppy mode одинаково);
  • const требует инициализатор при объявлении — кроме случаев for...of / for...in, где значение задаёт цикл.
let count = 0;
count = 1; // OK

const limit = 10;
// limit = 20; // TypeError: Assignment to constant variable.

const фиксирует биндинг, а не значение. Объект по ссылке можно менять:

const arr = [1, 2];
arr.push(3);      // OK
// arr = [1, 2, 3]; // TypeError

Если нужна настоящая неизменяемость, одного const недостаточно — применяют Object.freeze() (и помнят, что он поверхностный).

Сравнение

Свойствоvarletconst
Область видимостифункцияблокблок
Биндинг при входе в областьсразу undefinedбез значения (TDZ)без значения (TDZ)
Чтение до объявленияundefinedReferenceErrorReferenceError
Повторное объявлениеразрешеноSyntaxErrorSyntaxError
ПереприсваиваниедадаTypeError
Свойство globalThis (скрипт)данетнет

Конфликты объявлений — это ранние ошибки, а не ошибки времени выполнения. Код let a = 1; var a = 2; не выполнится вообще: SyntaxError: Identifier 'a' has already been declared возникнет ещё при разборе.

Что происходит на уровне движка

У контекста выполнения есть два компонента:

  • VariableEnvironment — окружение для var и function declarations;
  • LexicalEnvironment — окружение для let, const, class и блочных объявлений.

В теле функции оба обычно указывают на одно и то же окружение, поэтому var и let различаются только правилами создания биндинга. В глобальном скрипте окружение разделено на объектную и декларативную части. При входе в блок движок создаёт новое декларативное окружение и делает его текущим LexicalEnvironment, не трогая VariableEnvironment — отсюда и разная область видимости.


Hoisting и Temporal Dead Zone

Термина «hoisting» в тексте спецификации ECMAScript нет — это удобное описание наблюдаемого поведения. Реальный механизм такой:

  1. Разбор и компиляция. Движок читает весь скрипт или тело функции, строит дерево областей видимости и находит объявления. Синтаксические ошибки вроде let a; var a; обнаруживаются на этом этапе.
  2. Создание окружения (declaration instantiation). Перед выполнением инструкций движок создаёт биндинги: var — со значением undefined, function declarations — с готовым функциональным объектом, let/const/class — неинициализированными.
  3. Выполнение. Инструкции выполняются по порядку; в строке объявления лексический биндинг получает значение.

Hoisting происходит на каждый вызов функции, а не один раз на файл. У каждого вызова свой контекст и свои биндинги.

console.log(a); // undefined
var a = 5;

console.log(b); // ReferenceError: Cannot access 'b' before initialization
let b = 10;

Границы TDZ

TDZ начинается при входе в блок (а не в строке let) и заканчивается в момент инициализации биндинга. Поэтому «зона» определяется лексически, хотя слово temporal отсылает ко времени выполнения.

Из этого следуют неочевидные эффекты.

Самоссылка при инициализации. Правая часть вычисляется до того, как переменная получит значение:

let x = x; // ReferenceError: Cannot access 'x' before initialization

Затенение внешней переменной. Внутренний биндинг скрывает внешний с начала блока, даже если объявление ниже:

const value = 'outer';

function f() {
  console.log(value); // ReferenceError, а не 'outer'
  const value = 'inner';
}

typeof не является безопасной проверкой. Для необъявленного имени typeof возвращает 'undefined', но к биндингу в TDZ он всё равно обращается:

console.log(typeof notDeclared); // 'undefined'

console.log(typeof later); // ReferenceError
let later = 1;

switch — это один блок. Все case делят общее пространство имён, поэтому объявление в одном case видно в другом:

function getLabel(value) {
  switch (value) {
    case 1:
      const label = 'one';
      return label;
    case 2:
      return label; // ReferenceError, если value === 2
  }
}

Параметры по умолчанию инициализируются слева направо. Более поздний параметр ещё находится в TDZ:

function foo(a = b, b) {
  return [a, b];
}

foo(undefined, 1); // ReferenceError: Cannot access 'b' before initialization

Параметры по умолчанию вычисляются в отдельном окружении, внешнем по отношению к телу функции. Поэтому объявления из тела там ещё не видны:

function bar(callback = helper) {
  function helper() {}
  return callback;
}

bar(); // ReferenceError: helper is not defined

Класс в extends. Выражение наследования вычисляется до инициализации самого класса:

class C extends C {} // ReferenceError: Cannot access 'C' before initialization

Зачем нужен TDZ

TDZ превращает использование переменной до объявления в явную ошибку. Это даёт три эффекта:

  • ловит опечатки и логические ошибки на раннем этапе, а не превращает их в undefined;
  • делает const осмысленным: значение нельзя прочитать до инициализации;
  • убирает «магию» var, когда переменная доступна задолго до того места, где программист её объявил.

У var TDZ нет: биндинг сразу инициализирован undefined, поэтому чтение до объявления не различает «переменная не объявлена» и «объявлена, но ещё без значения».


Лексическое окружение

Лексическое окружение (Lexical Environment) — внутренняя структура, которая хранит биндинги и связывает область с её родителем. Концептуально его можно представить так:

LexicalEnvironment = {
  EnvironmentRecord: {
    x: 1,
    f: <function>,
  },
  [[OuterEnv]]: <внешнее окружение или null>,
}

Это не объект, доступный из JavaScript, а абстракция спецификации. Движки представляют её по-разному и оптимизируют, но семантика поиска имён остаётся такой.

Из чего состоит окружение

  1. Environment Record — хранилище биндингов. Бывает нескольких видов:
    • декларативная запись — let, const, class, параметры, catch-параметр;
    • объектная запись — свойства глобального объекта для глобальных var/функций, а также объект в with;
    • запись функции — параметры, arguments, привязка this;
    • запись модуля — верхний уровень модуля и импорты.
  2. Ссылка на внешнее окружение ([[OuterEnv]]) — указатель на окружение, в котором создано текущее.

Окружения выстраиваются в цепочку: глобальное → внешнее → вложенное. При обращении к переменной движок ищет её в текущей записи, затем по [[OuterEnv]] — и так до глобального. Эта цепочка и есть цепочка областей видимости (scope chain).

const globalName = 'global';

function outer() {
  const outerName = 'outer';

  function inner() {
    const innerName = 'inner';
    console.log(innerName, outerName, globalName);
  }

  inner();
}

outer(); // 'inner' 'outer' 'global'

Поиск outerName из inner проходит три шага: окружение inner → окружение outer → глобальное окружение. Если имени нет нигде, возникает ReferenceError (а не undefined).

Цепочка лексическая, а не динамическая

Важно, что функция ищет переменные там, где была объявлена, а не там, откуда её вызвали:

var x = 1;

function readX() {
  console.log(x);
}

function callReadX() {
  var x = 2;
  readX();
}

callReadX(); // 1, а не 2

readX создана в глобальном окружении, поэтому видит глобальный x. Вызов из функции с собственной x ничего не меняет — это лексическая область видимости.

Исключения из лексического правила — динамические механизмы:

  • with (obj) добавляет объектное окружение в цепочку на время блока (запрещён в strict mode);
  • прямой eval в sloppy mode может добавить var в окружение вызывающей функции.

Оба механизма считаются устаревшими и в современном коде не используются.

Окружение и замыкания

Каждая функция при создании получает скрытую ссылку на окружение, в котором объявлена. При вызове создаётся новое окружение вызова, а его [[OuterEnv]] указывает на сохранённое:

function makeCounter() {
  let count = 0;

  return function increment() {
    return ++count;
  };
}

const counter = makeCounter();
console.log(counter()); // 1
console.log(counter()); // 2

После завершения makeCounter её окружение не удаляется, потому что на него ссылается возвращённая функция. Так лексическое окружение превращается в замыкание. Подробнее — в статье «Замыкания и лексическое окружение».

При каждом вызове функции создаётся новое окружение:

function next() {
  let local = 0;
  return ++local;
}

console.log(next()); // 1
console.log(next()); // 1 — у каждого вызова свой local

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


Function declaration vs function expression

Function declaration

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

sayHi(); // 'Hi!'

function sayHi() {
  console.log('Hi!');
}

В strict mode function declaration внутри блока имеет блочную область видимости и инициализируется при входе в блок:

'use strict';

{
  console.log(f()); // 1
  function f() {
    return 1;
  }
}

В sloppy mode действует унаследованное поведение Annex B: функция, объявленная в блоке, дополнительно создаёт var-подобный биндинг во внешней функции, но присваивается только при выполнении блока:

function demo() {
  console.log(typeof f); // 'undefined' — var-биндинг уже есть, функции ещё нет
  if (true) {
    function f() {
      return 1;
    }
  }
  console.log(typeof f); // 'function'
}

Именно из-за этой неоднозначности function declarations внутри блоков не рекомендуются: в strict mode и в модулях они блочные, в sloppy mode — с побочным эффектом.

Function expression

В function expression функция является значением выражения, а не объявлением. Поднимается только переменная, в которую это значение будет записано:

sayBye(); // TypeError: sayBye is not a function

var sayBye = function () {
  console.log('Bye!');
};

С let/const до присваивания срабатывает TDZ:

sayBye(); // ReferenceError: Cannot access 'sayBye' before initialization

const sayBye = function () {
  console.log('Bye!');
};

Стрелочная функция ведёт себя как function expression: hoisting определяется ключевым словом переменной, а не самой стрелкой.

sum(1, 2); // ReferenceError

const sum = (a, b) => a + b;

Именованное function expression

Имя именованного function expression доступно только внутри самой функции:

const factorial = function fact(n) {
  return n <= 1 ? 1 : n * fact(n - 1);
};

console.log(factorial(5)); // 120
console.log(typeof fact);  // 'undefined'

Это удобно для рекурсии и читаемых stack trace. Сам биндинг fact внутри функции read-only: присваивание в strict mode даёт TypeError, в sloppy mode молча игнорируется.

Коллизии имён

Две function declaration с одним именем в одной области — валидный код, побеждает последняя:

function f() {
  function g() { return 1; }
  function g() { return 2; }
  return g();
}

f(); // 2

var и function declaration с одним именем тоже сосуществуют: функция создаётся при подготовке окружения, а var не сбрасывает её в undefined; дальнейшее присваивание меняет значение:

function f() {
  console.log(typeof foo); // 'function'
  var foo = 1;
  function foo() {}
  return foo; // 1
}

Сводка

ОбъявлениеЧто создаётся при подготовкеОбращение до строкиОбласть
Function declarationфункция целикомработаетфункция; внутри блока в strict mode — блок
Function expression + varпеременная undefinedTypeError при вызовефункция
Function expression + let/constбиндинг в TDZReferenceErrorблок
Стрелочная функция + var/let/constкак у переменнойзависит от ключевого словафункция/блок

Hoisting классов

Классы — это лексические объявления, как let и const. Их биндинг создаётся при входе в область, но остаётся в TDZ до вычисления class:

const dog = new Dog(); // ReferenceError: Cannot access 'Dog' before initialization

class Dog {}

То же касается typeof:

console.log(typeof Dog); // ReferenceError
class Dog {}

Классовое выражение подчиняется правилам переменной, в которую записано:

const Dog = class {}; // TDZ определяется const, а не самим классом

Выражение в extends вычисляется до инициализации класса, поэтому класс не может наследоваться от самого себя:

class C extends C {} // ReferenceError

Внутри тела класса имя класса доступно как read-only биндинг:

class C {
  static create() {
    return new C();
  }
}

Методы и поля не «поднимаются» по отдельности: тело класса вычисляется как единое целое при выполнении объявления. Сравните с функцией-конструктором, которая поднимается полностью:

new Cat(); // работает

function Cat() {}

Практические примеры: что выведет код

Пример 1. Затенение var

var x = 1;

function foo() {
  console.log(x); // ?
  var x = 2;
  console.log(x); // ?
}

foo();

Ответ: undefined, затем 2. Внутри foo создаётся собственная x, которая с начала вызова равна undefined и затеняет глобальную.

Пример 2. Затенение let

let a = 1;

function bar() {
  console.log(a); // ?
  let a = 2;
}

bar();

Ответ: ReferenceError. Внутри bar есть собственная a, и она находится в TDZ с начала тела функции. Обращение к внешней a невозможно: внутренний биндинг уже перекрыл её.

Пример 3. setTimeout в цикле

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}
// 3, 3, 3

for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j), 0);
}
// 0, 1, 2

var создаёт один биндинг на всю функцию, поэтому все колбэки читают одно и то же финальное значение 3. let в заголовке for создаёт новое окружение на каждую итерацию, и каждый колбэк замыкает свою переменную. В спецификации это описано через CreatePerIterationEnvironment: перед очередной итерацией движок создаёт окружение и копирует туда текущие значения биндингов.

Если нужно сохранить поведение var, используют IIFE или forEach:

for (var i = 0; i < 3; i++) {
  (function (j) {
    setTimeout(() => console.log(j), 0);
  })(i);
}
// 0, 1, 2

После цикла var i остаётся доступной и равна 3, а let j вне цикла не существует (typeof j === 'undefined').

Пример 4. typeof и TDZ

console.log(typeof value); // ?
let value = 1;

Ответ: ReferenceError. Биндинг value уже создан и скрывает любые внешние имена, но ещё не инициализирован. typeof не спасает: он проверяет существование имени, а не его готовность.

Пример 5. switch и общий блок

function getLabel(value) {
  switch (value) {
    case 1:
      let label = 'one';
      return label;
    case 2:
      return label; // ?
  }
}

getLabel(2);

Ответ: ReferenceError. Оба case находятся в одном блоке, label создана при входе в switch, но инициализируется только в ветке case 1. Если выполняется case 2, чтение попадает в TDZ.

Пример 6. Function declaration в блоке

function sloppy() {
  console.log(typeof f); // ?
  if (true) {
    function f() {}
  }
  console.log(typeof f); // ?
}

Ответ в sloppy mode: 'undefined', затем 'function'. Annex B создаёт var-подобный биндинг заранее, но функция присваивается ему только при выполнении блока. В strict mode и в модулях оба typeof вернут 'undefined': функция останется внутри блока.

Пример 7. var в невыполненной ветке

function f() {
  if (false) {
    var hidden = 1;
  }
  console.log(hidden); // ?
}

f();

Ответ: undefined. Объявление var hidden обрабатывается при входе в функцию, независимо от того, выполнится ли ветка if. Присваивание = 1 не выполняется, поэтому значение остаётся начальным.


Правила, которые убирают сюрпризы

  1. По умолчанию const, при необходимости переприсваивания — let. var в новом коде не нужен: он протекает из блоков и не даёт TDZ-защиты.
  2. Не полагайтесь на hoisting. Объявляйте переменные до использования: код должен читаться сверху вниз, а не требовать мысленного «поднятия» объявлений.
  3. Не используйте typeof как проверку лексического биндинга. Для let/const/class в TDZ он сам выбрасывает ReferenceError.
  4. Держите объявления в switch в отдельных блоках. Если в case нужна let/const, оберните ветку в {}:
    switch (value) {
      case 1: {
        const label = 'one';
        return label;
      }
    }
  5. Избегайте function declarations внутри блоков. В strict mode они блочные, в sloppy mode добавляется Annex B-биндинг во внешнюю функцию. Надёжнее const fn = () => {} или объявление на верхнем уровне.
  6. Помните, что const не делает объект неизменяемым. Для защиты данных нужен Object.freeze() или иммутабельные структуры.
  7. Не используйте with и прямой eval. Они добавляют динамические окружения и ломают предсказуемость лексической области видимости.

Ключевые тезисы для интервью

  • Область видимости — это лексическая область, в которой имя разрешается в биндинг; в современном JS есть глобальная, функциональная, блочная и модульная области.
  • var имеет функциональную область, создаётся сразу со значением undefined и не создаёт TDZ; let и const — блочные и до инициализации находятся в TDZ.
  • const запрещает переприсваивание биндинга, но не мутацию объекта; для неизменяемости нужен Object.freeze() или иммутабельные структуры.
  • Hoisting — не перемещение кода, а следствие подготовки окружения перед выполнением: движок заранее создаёт биндинги, а инициализирует их по ходу выполнения.
  • TDZ — состояние биндинга от входа в блок до инициализации; чтение, запись и даже typeof в этот момент дают ReferenceError.
  • Лексическое окружение состоит из Environment Record и ссылки [[OuterEnv]]; поиск переменной идёт по цепочке окружений до глобального.
  • Цепочка областей видимости лексическая: функция видит переменные места объявления, а не места вызова; на этом основаны замыкания.
  • Function declaration поднимается целиком и вызывается до своей строки; function expression поднимает только переменную — с var это TypeError, с let/const — ReferenceError.
  • Function declarations в блоках в strict mode блочные, а в sloppy mode Annex B добавляет var-подобный биндинг во внешнюю функцию.
  • Классы — лексические объявления: они поднимаются, но остаются в TDZ до вычисления class, поэтому new C() и typeof C до объявления дают ReferenceError.
  • let в заголовке for создаёт новую привязку на каждую итерацию, поэтому колбэки в setTimeout получают разные значения; var даёт одно значение на всю функцию.
  • В глобальном скрипте var и function declarations становятся свойствами globalThis, а let/const/class — нет: они живут в декларативной части глобального окружения.

Заключение

Область видимости и hoisting — не набор трюков, а следствие того, как движок создаёт окружения и биндинги перед выполнением кода. var даёт один биндинг на функцию и сразу инициализирует его undefined, а let/const создают блочные биндинги, которые до объявления находятся в TDZ. Function declarations поднимаются целиком, function expressions — только как переменные, а классы ведут себя как лексические объявления. Понимание лексических окружений и цепочки поиска объясняет не только «странные» примеры с setTimeout, но и работу замыканий, модулей и React-хуков. Практический вывод простой: используйте const и let, объявляйте переменные до использования, избегайте function declarations в блоках и не полагайтесь на typeof для проверки TDZ.

Полезные ссылки