Область видимости и hoisting
Почему console.log(x) до var x = 1 печатает undefined, а до let x = 1 падает с ReferenceError? Причина не в том, что движок «переставляет» строки, а в том, как он создаёт биндинги перед выполнением кода. Разберём уровни области видимости, TDZ, устройство лексических окружений и то, как hoisting работает для переменных, функций и классов — на уровне спецификации и на практических примерах.
Содержание
- Виды области видимости
var,let,const- Hoisting и Temporal Dead Zone
- Лексическое окружение
- Function declaration vs function expression
- Hoisting классов
- Практические примеры: что выведет код
- Правила, которые убирают сюрпризы
- Ключевые тезисы для интервью
- Заключение
- Полезные ссылки
Виды области видимости
Область видимости (scope) — это участок кода, в котором имя разрешается в конкретный биндинг. В современном JavaScript можно выделить четыре вида областей:
| Область | Где возникает | Что в ней объявляется |
|---|---|---|
| Глобальная (script) | верхний уровень скрипта | var, function declarations — в объектном окружении; let, const, class — в декларативном |
| Функциональная | тело функции, параметры | var, параметры, arguments, function declarations |
| Блочная | {}, if, for, switch, catch | let, 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() (и помнят, что он поверхностный).
Сравнение
| Свойство | var | let | const |
|---|---|---|---|
| Область видимости | функция | блок | блок |
| Биндинг при входе в область | сразу undefined | без значения (TDZ) | без значения (TDZ) |
| Чтение до объявления | undefined | ReferenceError | ReferenceError |
| Повторное объявление | разрешено | SyntaxError | SyntaxError |
| Переприсваивание | да | да | 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 нет — это удобное описание наблюдаемого поведения. Реальный механизм такой:
- Разбор и компиляция. Движок читает весь скрипт или тело функции, строит дерево областей видимости и находит объявления. Синтаксические ошибки вроде
let a; var a;обнаруживаются на этом этапе. - Создание окружения (declaration instantiation). Перед выполнением инструкций движок создаёт биндинги:
var— со значениемundefined, function declarations — с готовым функциональным объектом,let/const/class— неинициализированными. - Выполнение. Инструкции выполняются по порядку; в строке объявления лексический биндинг получает значение.
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, а абстракция спецификации. Движки представляют её по-разному и оптимизируют, но семантика поиска имён остаётся такой.
Из чего состоит окружение
- Environment Record — хранилище биндингов. Бывает нескольких видов:
- декларативная запись —
let,const,class, параметры,catch-параметр; - объектная запись — свойства глобального объекта для глобальных
var/функций, а также объект вwith; - запись функции — параметры,
arguments, привязкаthis; - запись модуля — верхний уровень модуля и импорты.
- декларативная запись —
- Ссылка на внешнее окружение (
[[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 | переменная undefined | TypeError при вызове | функция |
Function expression + let/const | биндинг в TDZ | ReferenceError | блок |
Стрелочная функция + 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 не выполняется, поэтому значение остаётся начальным.
Правила, которые убирают сюрпризы
- По умолчанию
const, при необходимости переприсваивания —let.varв новом коде не нужен: он протекает из блоков и не даёт TDZ-защиты. - Не полагайтесь на hoisting. Объявляйте переменные до использования: код должен читаться сверху вниз, а не требовать мысленного «поднятия» объявлений.
- Не используйте
typeofкак проверку лексического биндинга. Дляlet/const/classв TDZ он сам выбрасываетReferenceError. - Держите объявления в
switchв отдельных блоках. Если вcaseнужнаlet/const, оберните ветку в{}:switch (value) { case 1: { const label = 'one'; return label; } } - Избегайте function declarations внутри блоков. В strict mode они блочные, в sloppy mode добавляется Annex B-биндинг во внешнюю функцию. Надёжнее
const fn = () => {}или объявление на верхнем уровне. - Помните, что
constне делает объект неизменяемым. Для защиты данных нуженObject.freeze()или иммутабельные структуры. - Не используйте
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.