Переменная let
Определение и применение
Объявление let создаёт переменную, которую можно переприсвоить. Она имеет область видимости своего блока,
а на верхнем уровне — модуля или обычного скрипта. Имя существует с начала области видимости, но до выполнения
объявления чтение переменной или попытка присвоить ей значение вызывает ReferenceError.
Чтение до объявления вызывает ошибку, даже если объявление находится на следующей строке:
console.log(count); // ReferenceError: переменная ещё не инициализирована
let count = 1; // Эта строка не выполнится из-за ошибки вышеПопытка присвоить значение до объявления тоже вызывает ошибку:
count = 1; // ReferenceError: присваивание не заменяет инициализацию
let count; // Эта строка не выполнится из-за ошибки выше
При выполнении объявления происходит инициализация — переменная получает начальное значение.
Его можно указать после =. Если значение не задано, переменная получает undefined:
let count; // Начальное значение — undefined
let step = 1; // Начальное значение — число 1Объяснение на задачах — в уроке учебника «Переменные: let и const» и «Поднятие объявлений и TDZ».
Поддержка браузерами
Спецификация: ecma262
Поддерживается во всех основных браузерах с 2016 года.
| Возможность | Компьютеры | Мобильные | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
let | 49 Версия 49 выпущена в 2016 г. Версия 41 выпущена в 2015 г. — Удалено в 49; Частичная поддержка Примечание MDN (англ.) Strict mode is required. | 14 Версия 14 выпущена в 2016 г. Версия 12 выпущена в 2015 г. — Удалено в 14; Частичная поддержка Примечание MDN (англ.) In Edge 12 and 13, | 44 Версия 44 выпущена в 2016 г. Примечание MDN (англ.) Before Firefox 44, Before Firefox 46, a Firefox 54 adds support of | 17 | 10 | 49 Версия 49 выпущена в 2016 г. Версия 41 выпущена в 2015 г. — Удалено в 49; Частичная поддержка Примечание MDN (англ.) Strict mode is required. | 44 Версия 44 выпущена в 2016 г. Примечание MDN (англ.) Before Firefox for Android 44, Before Firefox for Android 46, a Firefox for Android 54 adds support of | 18 | 10 | 5.0 Версия 5.0 выпущена в 2016 г. Версия 4.0 выпущена в 2016 г. — Удалено в 5.0; Частичная поддержка Примечание MDN (англ.) Strict mode is required. | 49 Версия 49 выпущена в 2016 г. Версия 41 выпущена в 2015 г. — Удалено в 49; Частичная поддержка Примечание MDN (англ.) Strict mode is required. | 10 |
поддерживаетсяс ограниченияминет поддержкинет данных≤31 — не позднее версии 31
Синтаксис
// Без начального значения
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, циклов и самостоятельному блоку. Фигурные скобки литерала объекта сами по себе
такой области не создают.
Во вложенном блоке можно объявить переменную с тем же именем. Она затеняет внешнюю: внутри используется внутреннее имя, после выхода — снова внешнее. Это две разные переменные, поэтому изменение внутренней не затрагивает внешнюю:
let count = 1;
{
let count = 2; // Объявляем отдельную переменную внутри блока
count = 3; // Меняем только внутреннюю переменную
console.log(count); // 3
}
console.log(count); // 1: внешняя переменная не изменилась
Если внутри блока написать count = 2 без нового объявления let, код найдёт переменную
во внешней области и изменит её:
let count = 1;
{
count = 2; // Новую переменную не объявляем, меняем внешнюю
}
console.log(count); // 2: внешняя переменная изменилась
Повторное объявление в той же области запрещено, даже если значение совпадает. Конфликт возникает и с
const или var в этой области; нельзя также объявить let с именем параметра
непосредственно в теле функции. Это SyntaxError ещё до выполнения кода. Переприсваивание уже объявленной
переменной допустимо:
let price = 100;
price = 80; // Допустимо: изменяем значение
let price = 80; // SyntaxError: повторно объявляем имя
У веток case одного switch общая область видимости. Если в разных ветках нужны одноимённые
переменные, заключите тело каждой ветки в отдельный блок:
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 действует только после инициализации.
Обычное присваивание не заменяет инициализацию при объявлении. В этом фрагменте выполнение остановится на первой строке: переменная ещё не инициализирована, поэтому до объявления код не дойдёт.
count = 1; // ReferenceError: переменная ещё не инициализирована
let count;Теперь поменяем порядок: сначала объявление инициализирует переменную, затем присваивание меняет её значение.
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":
let count; // Переменная инициализирована значением undefined
console.log(typeof count); // "undefined" — строка, которую возвращает typeof
Чтение, присваивание и typeof до инициализации показаны в
примере с ценой.
«Временная» означает, что важен момент выполнения, а не только положение строки. Функцию, читающую переменную, можно создать выше её объявления. Если вызвать функцию после инициализации, она прочитает значение; если раньше — возникнет ошибка. После переприсваивания следующий вызов увидит новое значение: функция обращается к переменной, а не хранит снимок её первоначального значения. Проверьте это в примере с расчётом суммы.
Иногда говорят, что let «не поднимается». Точнее: привязка создаётся заранее, но не получает доступного
значения до выполнения объявления. Практическое правило — выполнять объявление до первого обращения к переменной, в
том числе из вызываемых функций.
Отличия 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.
Исключения
| Тип исключения | Описание |
|---|---|
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 lang="ru">
<head>
<meta charset="utf-8">
<title>Область и переприсваивание</title>
</head>
<body>
<script src="main.js"></script>
</body>
</html>
main.js
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 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
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 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
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 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
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())
Нажмите , чтобы запустить пример.