Константа const

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

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

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

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

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

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

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

JavaScript
const count = undefined; // Начальное значение — undefined, указано явно
const step = 1; // Начальное значение — число 1

Без начального значения обычное объявление const вызывает SyntaxError ещё до выполнения кода:

JavaScript
const count; // SyntaxError: отсутствует начальное значение

После инициализации значение можно читать, но попытка переприсвоить константу вызывает TypeError:

JavaScript
const count = 1;
console.log(count); // 1
count = 2; // TypeError: переприсваивание запрещено

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

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

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

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

Показать браузеры
Совместимостьjavascript.statements.const
ВозможностьКомпьютерыМобильные
ChromeEdgeFirefoxOperaSafariChrome AndroidFirefox for AndroidOpera AndroidSafari on iOSSamsung BrowserWebView AndroidWebView on iOS
const✓21✓12✓36✓9✓5.1✓25✓36✓10.1✓5✓1.5✓4.4✓5

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

Синтаксис

JavaScript
// Обычное объявление с начальным значением
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 ещё до выполнения кода.

JavaScript
const price = 100;
const price = 100; // SyntaxError: повторное объявление

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

JavaScript
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.

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

JavaScript
count = 1; // ReferenceError: константа ещё не инициализирована
const count = 2;

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

JavaScript
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
Ситуация 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 оставлять для счётчиков и накапливаемых значений: так видно, какие имена меняются.

Исключения

Исключения const
Тип исключения Описание
TypeError Присваивание константе: Assignment to constant variable.
SyntaxError Нет начального значения в обычном объявлении или повторно объявлено имя в той же области.
ReferenceError Чтение или присваивание до инициализации, включая typeof во временной мёртвой зоне.

Различайте три ситуации: повторное объявление — SyntaxError; обращение до инициализации — ReferenceError; переприсваивание после инициализации — TypeError. Если значение должно меняться, используйте let.

В примере Reflect.set() возвращает признак успеха записи. Вложенный объект остаётся изменяемым в примере с поверхностной заморозкой.

Примеры

Внутренняя константа не меняет внешнюю

Внутри блока price равна 80, снаружи — 100. Имя discount снаружи недоступно: получится ReferenceError. Измените внутреннюю цену и проверьте, что внешняя осталась прежней.

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 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
<!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
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
<!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)
}

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

Содержимое меняется, привязка — нет

Вывод: 2 — массив изменился, затем TypeError: Assignment to constant variable. Добавьте ещё один товар, затем сравните изменение массива с присваиванием нового массива. Текст ошибки зависит от движка.

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
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
<!doctype html>
<html lang="ru">
<head>
  <meta charset="utf-8">
  <title>Заморозка не распространяется на вложенные объекты</title>
</head>
<body>
  <script src="main.js"></script>
</body>
</html>
main.js
JavaScript
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)

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

ECMAScript: Let and Const Declarations.