Переменная let

Определение и применение

Объявление let создаёт переменную, которую можно переприсвоить. Она имеет область видимости своего блока, а на верхнем уровне — модуля или обычного скрипта. Имя существует с начала области видимости, но до выполнения объявления чтение переменной или попытка присвоить ей значение вызывает ReferenceError.

Чтение до объявления вызывает ошибку, даже если объявление находится на следующей строке:

JavaScript
console.log(count); // ReferenceError: переменная ещё не инициализирована
let count = 1; // Эта строка не выполнится из-за ошибки выше

Попытка присвоить значение до объявления тоже вызывает ошибку:

JavaScript
count = 1; // ReferenceError: присваивание не заменяет инициализацию
let count; // Эта строка не выполнится из-за ошибки выше

При выполнении объявления происходит инициализация — переменная получает начальное значение. Его можно указать после =. Если значение не задано, переменная получает undefined:

JavaScript
let count; // Начальное значение — undefined
let step = 1; // Начальное значение — число 1

Объяснение на задачах — в уроке учебника «Переменные: let и const» и «Поднятие объявлений и TDZ».

Поддержка браузерами

Спецификация: ecma262

Поддерживается во всех основных браузерах с 2016 года.

Показать браузеры
Совместимостьjavascript.statements.let
ВозможностьКомпьютерыМобильные
ChromeEdgeFirefoxOperaSafariChrome AndroidFirefox for AndroidOpera AndroidSafari on iOSSamsung BrowserWebView AndroidWebView on iOS
let✓49✓14✓44✓17✓10✓49✓44✓18✓10✓5.0✓49✓10

поддерживаетсяс ограниченияминет поддержкинет данных≤31 — не позднее версии 31

Синтаксис

JavaScript
// Без начального значения
let count;

// С начальным значением
let step = 1;

// С деструктуризацией — получаем значения из объекта или массива
let { title, price } = { title: 'Чай', price: 100 };
let [first, second] = [10, 20];

После let указывают имя переменной, а после = — выражение начального значения. В первом варианте count получает undefined, во втором step получает число 1. В одном объявлении можно перечислить несколько переменных через запятую: let a = 1, b = 2;.

Деструктуризация позволяет объявить несколько переменных, получив значения из объекта или массива. В записи с { } имена соответствуют свойствам объекта: title получает строку 'Чай', а price — число 100. В записи с [ ] важен порядок элементов: first получает 10, а second — 20.

При деструктуризации начальное значение обязательно. Исключение — объявление переменных перебора в for...of, for...in и for await...of: там значение на каждой итерации задаёт сам цикл.

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

Область видимости определяет, из каких частей кода можно обратиться к имени. У let она блочная: объявление внутри { } блока доступно в нём и вложенных блоках, но не снаружи. Это относится к телу функции, блокам if, циклов и самостоятельному блоку. Фигурные скобки литерала объекта сами по себе такой области не создают.

Во вложенном блоке можно объявить переменную с тем же именем. Она затеняет внешнюю: внутри используется внутреннее имя, после выхода — снова внешнее. Это две разные переменные, поэтому изменение внутренней не затрагивает внешнюю:

JavaScript
let count = 1;
{
  let count = 2; // Объявляем отдельную переменную внутри блока
  count = 3; // Меняем только внутреннюю переменную
  console.log(count); // 3
}
console.log(count); // 1: внешняя переменная не изменилась

Если внутри блока написать count = 2 без нового объявления let, код найдёт переменную во внешней области и изменит её:

JavaScript
let count = 1;
{
  count = 2; // Новую переменную не объявляем, меняем внешнюю
}
console.log(count); // 2: внешняя переменная изменилась

Повторное объявление в той же области запрещено, даже если значение совпадает. Конфликт возникает и с const или var в этой области; нельзя также объявить let с именем параметра непосредственно в теле функции. Это SyntaxError ещё до выполнения кода. Переприсваивание уже объявленной переменной допустимо:

JavaScript
let price = 100;
price = 80;     // Допустимо: изменяем значение
let price = 80; // SyntaxError: повторно объявляем имя

У веток case одного switch общая область видимости. Если в разных ветках нужны одноимённые переменные, заключите тело каждой ветки в отдельный блок:

JavaScript
const delivery = 'pickup';
switch (delivery) {
  case 'pickup': {
    let fee = 0;
    console.log(fee);
    break;
  }
  case 'courier': {
    let fee = 300;
    fee += 50;
    console.log(fee);
    break;
  }
}

На верхнем уровне обычного браузерного скрипта let создаёт глобальную привязку, но не свойство window или globalThis. Поэтому обращение по имени и чтение свойства глобального объекта — разные операции. В <script type="module"> имя принадлежит модулю: другие модули получают к нему доступ через export и import.

Временная мёртвая зона (TDZ)

Временная мёртвая зона (TDZ, англ. temporal dead zone) начинается при входе в область видимости и заканчивается, когда выполнено объявление и переменная получила начальное значение. До этого имя уже существует, но значения для чтения ещё нет. Чтение или попытка присваивания вызывает ReferenceError. Возможность переприсваивать let действует только после инициализации.

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

JavaScript
count = 1; // ReferenceError: переменная ещё не инициализирована
let count;

Теперь поменяем порядок: сначала объявление инициализирует переменную, затем присваивание меняет её значение.

JavaScript
let count; // Инициализация значением undefined
count = 1; // Присваивание нового значения
console.log(count); // 1

До выполнения let count; переменная ещё не равна undefined. В примере без начального значения видно три этапа: ошибка до объявления, undefined после него и число после присваивания.

Если справа от = есть выражение, инициализация завершается после его вычисления. Поэтому let price = price + 1 не работает: справа код читает ещё не инициализированную переменную. Если снаружи есть другая price, она не поможет — внутреннее имя затеняет её с начала блока, ещё до строки объявления.

Оператор typeof тоже не обходит TDZ. Для необъявленного имени он возвращает строку "undefined", но для существующей, ещё не инициализированной переменной выбрасывает ReferenceError. После let count; вызов typeof count уже допустим и возвращает "undefined":

JavaScript
let count; // Переменная инициализирована значением undefined
console.log(typeof count); // "undefined" — строка, которую возвращает typeof

Чтение, присваивание и typeof до инициализации показаны в примере с ценой.

«Временная» означает, что важен момент выполнения, а не только положение строки. Функцию, читающую переменную, можно создать выше её объявления. Если вызвать функцию после инициализации, она прочитает значение; если раньше — возникнет ошибка. После переприсваивания следующий вызов увидит новое значение: функция обращается к переменной, а не хранит снимок её первоначального значения. Проверьте это в примере с расчётом суммы.

Иногда говорят, что let «не поднимается». Точнее: привязка создаётся заранее, но не получает доступного значения до выполнения объявления. Практическое правило — выполнять объявление до первого обращения к переменной, в том числе из вызываемых функций.

Отличия let от var

И let, и var позволяют переприсваивать переменную. Разница — в области видимости и в том, когда имя становится доступно:

Сравнение let и var
Ситуация let var
Объявление внутри блока if Имя доступно только в этом блоке и вложенных областях. Блок не ограничивает имя: оно принадлежит окружающей функции, модулю или глобальной области скрипта.
Чтение до выполнения объявления ReferenceError: переменная находится в TDZ. Переменная заранее инициализирована значением undefined. Начальное выражение вычисляется только при выполнении объявления.
Повторное объявление в той же области Запрещено: SyntaxError. Повторное var допустимо и обращается к той же переменной. Конфликт с let или const по-прежнему запрещён.
Объявление счётчика в заголовке for У каждой итерации своя переменная. Функции, созданные в теле цикла, обращаются к переменной своей итерации. Все итерации используют одну переменную. Функции читают её значение на момент вызова.
Верхний уровень обычного браузерного скрипта Не создаёт свойство window. Глобальная переменная становится свойством window. В модуле этого не происходит.

Например, после if (true) { var count = 1; } имя count доступно за пределами блока. После if (true) { let count = 1; } внутренняя переменная снаружи недоступна. Поэтому при замене var на let проверяйте обращения за пределами блока, до объявления и из функций, созданных в цикле: одной замены ключевого слова может быть недостаточно.

Особенности применения

В заголовке цикла for (let i = 0; ...) на каждой итерации создаётся новая переменная i, поэтому функции из тела запоминают своё значение.

Используйте let для счётчиков, накапливаемых значений и состояния, которое будет переприсваиваться. Если переприсваивание не нужно, объявляйте через const.

Исключения

Исключения let
Тип исключения Описание
ReferenceError Чтение или присваивание до инициализации, в том числе typeof x в TDZ и let x = x.
SyntaxError Повторное объявление того же имени в той же области: Identifier 'x' has already been declared.

Примеры

Область и переприсваивание

Вывод: внутри: 2, снаружи: 1 — во вложенном блоке своя переменная count. Затем итог: 3. Уберите let перед внутренним count = 2: изменится внешняя переменная, и вывод станет внутри: 2, снаружи: 2, итог: 4.

index.html
HTML
<!doctype html>
<html lang="ru">
<head>
  <meta charset="utf-8">
  <title>Область и переприсваивание</title>
</head>
<body>
  <script src="main.js"></script>
</body>
</html>
main.js
JavaScript
let count = 1;
{
  let count = 2;
  console.log("внутри: " + count);
}
console.log("снаружи: " + count);

count += 2;
console.log("итог: " + count);

Чтение, запись и typeof до инициализации

Внутренняя price затеняет внешнюю с начала блока: чтение, присваивание и typeof дают ReferenceError. Перенесите let price = 80 в начало блока перед первым try: ошибки исчезнут, присваивание изменит цену на 90. Затем попробуйте let price = price + 1 — ошибка возникнет при инициализации.

index.html
HTML
<!doctype html>
<html lang="ru">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Чтение, запись и typeof до инициализации</title>
  </head>
  <body>
    <script src="main.js"></script>
  </body>
</html>
main.js
JavaScript
let price = 100

{
    // Внутренняя price затеняет внешнюю уже с начала блока.
    try {
        console.log('Чтение:', price)
    } catch (error) {
        console.log('Чтение:', error.name)
    }

    try {
        price = 90
        console.log('Запись:', price)
    } catch (error) {
        console.log('Запись:', error.name)
    }

    try {
        console.log('typeof:', typeof price)
    } catch (error) {
        console.log('typeof:', error.name)
    }

    let price = 80
    console.log('После инициализации:', price)
}

console.log('Внешняя цена:', price)
// Такого имени нигде не объявлено: это другой случай, не TDZ.
console.log('Необъявленное имя:', typeof missingLetDemoName)

Объявление без начального значения

До let count получается ReferenceError, после — undefined, а после присваивания — 3. Замените let count на let count = 0: до объявления ошибка сохранится, после него появится 0.

index.html
HTML
<!doctype html>
<html lang="ru">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Объявление без начального значения</title>
  </head>
  <body>
    <script src="main.js"></script>
  </body>
</html>
main.js
JavaScript
try {
    console.log('До объявления:', count)
} catch (error) {
    console.log('До объявления:', error.name)
}

let count
console.log('После объявления:', count)

count = 3
console.log('После присваивания:', count)

Функция читает текущее значение переменной

Первый вызов getTotal() даёт ReferenceError, после инициализации — 300, после переприсваивания — 400. Перенесите let price = 150 перед первым try: первый вызов тоже вернёт 300.

index.html
HTML
<!doctype html>
<html lang="ru">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Функция читает текущее значение переменной</title>
  </head>
  <body>
    <script src="main.js"></script>
  </body>
</html>
main.js
JavaScript
const getTotal = () => price * 2

// Создание функции не читает price. Чтение произойдёт при вызове.
try {
    console.log('Ранний вызов:', getTotal())
} catch (error) {
    console.log('Ранний вызов:', error.name)
}

let price = 150
console.log('После инициализации:', getTotal())

price = 200
console.log('После переприсваивания:', getTotal())

Спецификация

ECMAScript: Let and Const Declarations.