Константа const
Определение и применение
Объявление const создаёт переменную, которой задают начальное значение и которую затем нельзя
переприсвоить. Она видна в своём блоке и вложенных областях, а на верхнем уровне — в модуле или
обычном скрипте. Имя существует с начала области видимости, но до выполнения объявления чтение переменной или
попытка присвоить ей значение вызывает ReferenceError.
Чтение до объявления вызывает ошибку, даже если объявление находится на следующей строке:
console.log(count); // ReferenceError: константа ещё не инициализирована
const count = 1; // Эта строка не выполнится из-за ошибки вышеПопытка присвоить значение до объявления тоже вызывает ошибку:
count = 1; // ReferenceError: присваивание не заменяет инициализацию
const count = 2; // Эта строка не выполнится из-за ошибки выше
При выполнении объявления происходит инициализация — константа получает начальное значение.
В обычном объявлении его обязательно указывают после =. Можно задать и undefined,
но только явно:
const count = undefined; // Начальное значение — undefined, указано явно
const step = 1; // Начальное значение — число 1
Без начального значения обычное объявление const вызывает SyntaxError ещё до выполнения
кода:
const count; // SyntaxError: отсутствует начальное значение
После инициализации значение можно читать, но попытка переприсвоить константу вызывает TypeError:
const count = 1;
console.log(count); // 1
count = 2; // TypeError: переприсваивание запрещеноОбъяснение на задачах — в уроке учебника «Переменные: let и const» и «Значения и ссылки».
Поддержка браузерами
Спецификация: ecma262
Поддерживается во всех основных браузерах с 2015 года.
| Возможность | Компьютеры | Мобильные | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
const | 21 | 12 | 36 Версия 36 выпущена в 2015 г. Примечание MDN (англ.) Before Firefox 13, Before Firefox 46, a | 9 | 5.1 | 25 | 36 Версия 36 выпущена в 2015 г. Примечание MDN (англ.) Before Firefox for Android 14, Before Firefox for Android 46, a | 10.1 | 5 | 1.5 | 4.4 | 5 |
поддерживаетсяс ограниченияминет поддержкинет данных≤31 — не позднее версии 31
Синтаксис
// Обычное объявление с начальным значением
const count = 1;
// Деструктуризация объекта — получаем значения по именам свойств
const { title, price } = { title: 'Чай', price: 100 };
// Деструктуризация массива — получаем значения по порядку элементов
const [first, second] = [10, 20];
После const указывают имя константы или шаблон деструктуризации, а после = — выражение
начального значения. В первом варианте count получает число 1. В одном объявлении можно
перечислить несколько констант через запятую: const a = 1, b = 2;.
Деструктуризация позволяет объявить несколько констант, получив значения из объекта или массива.
В записи с { } имена соответствуют свойствам объекта: title получает строку
'Чай', а price — число 100. В записи с [ ] важен порядок элементов:
first получает 10, а second — 20.
В обычном объявлении начальное значение обязательно для каждой константы. Без него возникает
SyntaxError: Missing initializer in const declaration. Исключение — объявление переменных перебора в
for...of, for...in и for await...of: там значение на каждой итерации задаёт сам цикл.
Область видимости
Область видимости определяет, из каких частей кода можно обратиться к имени. У const она
блочная: объявление внутри { } блока доступно в нём и вложенных блоках, но не снаружи. Это относится к
телу функции, блокам if, циклов и самостоятельному блоку. Фигурные скобки литерала объекта сами по себе
такой области не создают.
Во вложенном блоке можно объявить константу с тем же именем. Она затеняет внешнюю: внутри используется внутреннее имя, после выхода — снова внешнее. Это две разные привязки, поэтому запрет переприсваивания не нарушается. В примере с ценой внутреннее значение не меняет внешнее.
Повторное объявление в той же области запрещено, даже если значение совпадает. Конфликт возникает и с
let или var в этой области; нельзя также объявить const с именем параметра
непосредственно в теле функции. Это SyntaxError ещё до выполнения кода.
const price = 100;
const price = 100; // SyntaxError: повторное объявление
У веток case одного switch общая область видимости. Если в разных ветках нужны одноимённые
константы, заключите тело каждой ветки в отдельный блок:
const delivery = 'pickup';
switch (delivery) {
case 'pickup': {
const fee = 0;
console.log(fee);
break;
}
case 'courier': {
const fee = 300;
console.log(fee);
break;
}
}
На верхнем уровне обычного браузерного скрипта const создаёт глобальную привязку, но не свойство
window или globalThis. Поэтому обращение по имени и чтение свойства глобального объекта —
разные операции. В <script type="module"> имя принадлежит модулю: другие модули получают к нему
доступ через export и import.
Временная мёртвая зона (TDZ)
Временная мёртвая зона (TDZ, англ. temporal dead zone) начинается при входе в область видимости и заканчивается, когда
выполнено объявление и константа получила начальное значение. До этого имя уже существует, но значения для чтения ещё
нет. Оно не равно undefined: чтение или попытка присваивания вызывает ReferenceError.
Обычное присваивание не заменяет инициализацию при объявлении. В этом фрагменте выполнение остановится на первой строке: константа ещё не инициализирована, поэтому до объявления код не дойдёт.
count = 1; // ReferenceError: константа ещё не инициализирована
const count = 2;
Теперь сначала выполним объявление: начальное значение можно прочитать,
но последующее присваивание вызовет уже TypeError, потому что константу нельзя переприсвоить.
const count = 2; // Инициализация значением 2
console.log(count); // 2
count = 1; // TypeError: переприсваивание запрещено
Инициализация завершается только после вычисления выражения справа от =. Поэтому
const price = price + 1 не работает: справа код пытается прочитать ещё не инициализированную константу.
Если снаружи есть другая price, она не поможет — внутреннее имя затеняет её с начала блока, ещё до строки
объявления.
Оператор typeof тоже не обходит TDZ. Для необъявленного имени typeof возвращает строку
"undefined", но для существующей, ещё не инициализированной константы выбрасывает
ReferenceError. Оба случая можно сравнить в примере ниже.
«Временная» означает, что важен момент выполнения, а не только положение строки. Функцию, читающую константу, можно создать выше её объявления. Если вызвать функцию после инициализации, она прочитает значение; если раньше — возникнет ошибка. Это показано в примере с расчётом суммы.
Иногда говорят, что const «не поднимается». Точнее: привязка создаётся заранее, но не получает доступного
значения до выполнения объявления. Практическое правило — инициализировать константу до первого обращения к ней, в том
числе из вызываемых функций. В отличие от let count;, обычное объявление
const count; недопустимо; const count = undefined; допустимо, поскольку начальное значение
указано явно.
Отличия const от var
При замене
var
на const меняется не только возможность переприсваивания. У const также блочная область
видимости и TDZ, поэтому сначала проверьте, где объявляется и используется переменная.
| Ситуация | const |
var |
|---|---|---|
Объявление внутри блока if |
Имя доступно только в этом блоке и вложенных областях. | Блок не ограничивает имя: оно принадлежит окружающей функции, модулю или глобальной области скрипта. |
| Чтение до выполнения объявления | ReferenceError: константа находится в TDZ. |
Переменная заранее инициализирована значением undefined. Начальное выражение вычисляется только
при выполнении объявления.
|
| Обычное объявление без начального значения |
const count; вызывает SyntaxError. В for...of и
for...in значение задаёт сам перебор.
|
var count; допустимо. Само это объявление не присваивает нового значения. |
| Переприсваивание после инициализации | Запрещено: TypeError. Свойства объекта и элементы массива менять можно. |
Допустимо: переменной можно присвоить другое значение. |
| Повторное объявление в той же области | Запрещено: SyntaxError. |
Повторное var допустимо и обращается к той же переменной. Конфликт с let или
const по-прежнему запрещён.
|
Объявление в заголовке for...of |
На каждой итерации создаётся отдельная константа. | На каждой итерации новое значение присваивается одной и той же переменной. |
| Верхний уровень обычного браузерного скрипта | Не создаёт свойство window. |
Глобальная переменная становится свойством window. В модуле этого не происходит.
|
Например, после var count = 1; операция count += 1 допустима, а после
const count = 1; она вызывает TypeError. Если значение должно меняться, выбирайте
let. Изменение свойств объекта само по себе не требует замены const: запрет относится к
присваиванию нового значения самой переменной.
Особенности применения
const запрещает менять привязку имени, а не содержимое значения. Как показывает
пример с корзиной, если в константе объект или массив, его свойства
и элементы можно менять: cart.push(item) работает.
Object.freeze()
запрещает добавлять и удалять собственные свойства объекта и менять значения его собственных свойств данных. Это
поверхностная заморозка: вложенные объекты автоматически не замораживаются.
Присваивание константе — TypeError: Assignment to constant variable во время выполнения, в том числе
count++ и count += 1.
В for...of и for...in можно писать const: на каждой итерации создаётся новая
константа. В обычном for (const i = 0; i < 3; i++) — ошибка, потому что шаг меняет i.
Рекомендуется объявлять через const всё, что не переприсваивается, а let оставлять для
счётчиков и накапливаемых значений: так видно, какие имена меняются.
Исключения
| Тип исключения | Описание |
|---|---|
TypeError |
Присваивание константе: Assignment to constant variable. |
SyntaxError |
Нет начального значения в обычном объявлении или повторно объявлено имя в той же области. |
ReferenceError |
Чтение или присваивание до инициализации, включая typeof во временной мёртвой зоне.
|
Различайте три ситуации: повторное объявление — SyntaxError; обращение до инициализации —
ReferenceError; переприсваивание после инициализации — TypeError. Если значение должно
меняться, используйте
let.
В примере
Reflect.set()
возвращает признак успеха записи. Вложенный объект остаётся изменяемым в
примере с поверхностной заморозкой.
Примеры
Внутренняя константа не меняет внешнюю
Внутри блока price равна 80, снаружи — 100. Имя discount снаружи недоступно: получится ReferenceError. Измените внутреннюю цену и проверьте, что внешняя осталась прежней.
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 price = 100
{
const price = 80
const discount = 20
console.log('Внутри:', price)
console.log('Скидка:', discount)
}
console.log('Снаружи:', price)
try {
console.log(discount)
} catch (error) {
console.log('Скидка снаружи:', error.name)
}
Нажмите , чтобы запустить пример.
Чтение и typeof до инициализации
До объявления внутренней price чтение и typeof price дают ReferenceError, хотя снаружи уже есть цена. Перенесите const price = 80 в начало блока перед первым try: оба обращения заработают. Затем попробуйте const 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
const price = 100
{
// Внутренняя price затеняет внешнюю уже с начала блока.
try {
console.log('Чтение:', price)
} catch (error) {
console.log('Чтение:', error.name)
}
try {
console.log('typeof:', typeof price)
} catch (error) {
console.log('typeof:', error.name)
}
const price = 80
console.log('После инициализации:', price)
}
console.log('Внешняя цена:', price)
// Такого имени нигде не объявлено: это другой случай, не TDZ.
console.log('Необъявленное имя:', typeof missingConstDemoName)
Нажмите , чтобы запустить пример.
Функция создана раньше, а значение прочитано позже
Первый вызов getTotal() даёт ReferenceError, второй возвращает 300. Перенесите const price = 150 перед первым try: оба вызова станут успешными, хотя сама функция по-прежнему объявлена выше константы.
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)
}
const price = 150
console.log('После инициализации:', getTotal())
Нажмите , чтобы запустить пример.
Содержимое меняется, привязка — нет
Вывод: 2 — массив изменился, затем TypeError: Assignment to constant variable. Добавьте ещё один товар, затем сравните изменение массива с присваиванием нового массива. Текст ошибки зависит от движка.
index.html
<html lang="ru">
<head>
<meta charset="utf-8">
<title>Содержимое меняется, привязка — нет</title>
</head>
<body>
<script src="main.js"></script>
</body>
</html>
main.js
const cart = ["tea"];
cart.push("honey");
console.log(cart.length);
try {
cart = [];
} catch (error) {
console.log(error.name + ": " + error.message);
}
Нажмите , чтобы запустить пример.
Заморозка не распространяется на вложенные объекты
Вывод: Чай, затем 2: название товара осталось прежним, но вложенный остаток изменился. Заморозьте product.stock перед присваиванием — остаток останется 1.
index.html
<html lang="ru">
<head>
<meta charset="utf-8">
<title>Заморозка не распространяется на вложенные объекты</title>
</head>
<body>
<script src="main.js"></script>
</body>
</html>
main.js
const product = Object.freeze({ title: 'Чай', stock: { count: 1 } })
// Reflect.set возвращает false, если изменить свойство нельзя.
Reflect.set(product, 'title', 'Кофе')
product.stock.count = 2
console.log(product.title)
console.log(product.stock.count)
Нажмите , чтобы запустить пример.