ФАЗА 33. JAVASCRIPT Область видимости

Лексическая область, поднятие и TDZ

var · let · const · Closures

Место объявления определяет доступность переменной, а let и const защищает временная мёртвая зона до инициализации.

1. Область определяется вложенностью кода

1 / 5

Внутренняя функция видит внешние переменные, внешняя не видит локальные имена внутренней. Выбор зависит от места определения, не вызова.

  • Блок создаёт лексическую границу.
  • Поиск идёт наружу по уровням.
  • Параметр принадлежит функции.
Глобальная областьФункцияВложенный блок

2. var привязан к функции, let и const к блоку

2 / 5

var доступен за пределами if внутри функции, блочные объявления не выходят за фигурные скобки.

  • Один var может быть объявлен повторно.
  • let не допускает повтор в той же области.
  • const сохраняет блочные правила.
var: функциональная областьlet и const: блок

3. Поднятие не выполняет инициализацию заранее

3 / 5

Объявление var регистрируется с undefined, function declaration поднимается целиком, let и const находятся в TDZ до строки инициализации.

  • Значение var появляется после присваивания.
  • TDZ вызывает ReferenceError.
  • Функция-выражение не равна объявлению.
Регистрация объявленияTDZ или undefinedИнициализация

4. var в цикле делит одну переменную

4 / 5

Все таймеры ссылаются на одну привязку и видят итоговое i. let создаёт новую привязку для каждой итерации.

  • Callback выполняется после цикла.
  • IIFE тоже создаёт отдельную область.
  • Современное решение использует let.
Итерация с letСвоя привязкаCallback видит своё i

5. Модули ограничивают глобальные имена

5 / 5

Импорт и экспорт связывают объявления модулей, а случайная глобальная переменная не нужна для обмена данными.

  • Модуль имеет собственную область.
  • Экспорт делается явно.
  • Глобальный объект не используют как хранилище.
Модульная границаЛокальные именаЭкспортИмпорт

Область видимости: var, let, const и поднятие

← назад к разделу

Область видимости (scope) отвечает на вопрос «откуда видна эта переменная». В JavaScript она лексическая — определяется тем, где переменная написана в коде, а не тем, откуда её пытаются прочитать во время выполнения. Это простое правило, но вокруг него наслоились три исторических сюжета: var, поднятие и мёртвая зона. Разберём все.

Лексическая вложенность

Области видимости вкладываются как матрёшки: функция видит свои переменные, переменные функции-родителя и глобальные — но не наоборот.

const outer = "внешняя";

function parent() {
  const middle = "средняя";
  function child() {
    const inner = "внутренняя";
    console.log(outer, middle, inner); // видит все три
  }
  child();
  // console.log(inner); // ReferenceError — внутрь заглянуть нельзя
}

Поиск имени идёт изнутри наружу: сначала своя область, потом родительская, и так до глобальной. Первое найденное имя побеждает — внутренняя переменная затеняет (shadowing) внешнюю с тем же именем.

var против let/const: функция против блока

var — довоенный способ объявления, и его область — вся функция, а не блок:

function demo() {
  if (true) {
    var v = 1;
    let l = 2;
  }
  console.log(v); // 1 — var «вытек» из блока
  console.log(l); // ReferenceError — let живёт только в блоке
}

let и const — блочные: живут внутри ближайших {}. Разница между ними одна: const запрещает переприсваивание. Важный нюанс: const не делает объект неизменяемым — менять содержимое можно, нельзя лишь перенаправить ссылку:

const arr = [1, 2];
arr.push(3);   // можно — меняем содержимое
arr = [];      // TypeError — нельзя перенаправить

Современное правило: const по умолчанию, let — когда переприсваивание действительно нужно, var — никогда.

Поднятие: почему код видит переменные «до» объявления

Перед выполнением движок сканирует область и «узнаёт» обо всех объявлениях заранее — это называют поднятием (hoisting). Но поднимаются объявления по-разному:

console.log(v);  // undefined — var поднят и инициализирован undefined
var v = 1;

console.log(l);  // ReferenceError! — let поднят, но НЕ инициализирован
let l = 2;

hi();            // "привет" — функция-объявление поднята ЦЕЛИКОМ
function hi() { console.log("привет"); }

bye();           // ReferenceError — const поднят, но до своей строки он в мёртвой зоне
const bye = () => console.log("пока");

Замените в последнем примере const на var — ошибка станет другой: TypeError: bye is not a function. Переменная уже есть, но в ней undefined, и это как раз тот молчаливый режим, от которого ушли let и const.

Зона от начала блока до строки let/const называется временной мёртвой зоной (TDZ): переменная уже «существует», но читать её — ошибка. Это осознанный дизайн: лучше упасть с ReferenceError, чем молча получить undefined, как с var.

Практический вывод: function declaration можно вызывать до объявления (удобно класть главную функцию файла наверх, помощников — вниз); стрелочные функции в const — только после.

Классика: var в цикле

Легендарная задачка, которая ловила поколения разработчиков:

живой пример

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 10);
}
// 3, 3, 3 — а не 0, 1, 2!
Запустить

Запуск примеров доступен в платном доступе. Там этот же код выполняется прямо в статье: редактор, запуск и проверка рядом с абзацем. Три дня бесплатно →

Почему: var i — одна переменная на весь цикл (функциональная область). Все три колбэка замкнулись на неё одну, а к моменту срабатывания таймеров цикл закончился и i === 3.

живой пример

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 10);
}
// 0, 1, 2 — let создаёт НОВУЮ переменную на каждую итерацию
Запустить

Запуск примеров доступен в платном доступе. Там этот же код выполняется прямо в статье: редактор, запуск и проверка рядом с абзацем. Три дня бесплатно →

Это не магия таймеров, а чистый scope: let в заголовке цикла означает «свежая переменная на каждый виток». Одна строчка — два разных мира.

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

Каждый ES-модуль (файл с import/export) — своя область видимости: переменные верхнего уровня файла не попадают в глобальную. Глобальную область сегодня загрязняют разве что скрипты без модулей и присваивания без объявления.

Коротко

С модулями связан и вопрос про "use strict". Строгий режим запрещает присваивание необъявленной переменной, которое раньше молча создавало глобальную, превращает тихие ошибки вроде записи в неизменяемое свойство в исключения и делает this в обычной функции undefined вместо глобального объекта. В ES-модулях и внутри class он включён всегда, а директиву пишут только в старых скриптах и CommonJS-файлах.

  • Scope лексический: важно, где переменная написана. Поиск имён — изнутри наружу, внутренняя затеняет внешнюю.
  • var — область функции, let/const — блока. Правило: const по умолчанию, let по необходимости, var — никогда.
  • const запрещает переприсваивание, но не изменение содержимого объекта.
  • Поднятие: function declaration доступна до объявления целиком; let/const до строки объявления — мёртвая зона (ReferenceError); var даёт молчаливый undefined.
  • var в цикле — одна переменная на все итерации, let — новая на каждую. Отсюда 3, 3, 3 против 0, 1, 2.

Что почитать дальше

  • Замыкания — что происходит, когда функция уносит область видимости с собой.
  • Приведение типов — предыдущая тема цикла.
  • Event loop — почему setTimeout из примера сработал после конца цикла.