Какая область видимости у const?

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

Область видимости (scope) — это диапазон кода, где переменная доступна. Ключевое слово const имеет блочную область видимости (block scope), что в современном JavaScript делает его одним из самых предсказуемых способов объявления переменных.

Блочная область видимости

const существует только внутри блока { }, где она объявлена. После закрытия блока переменная перестаёт существовать.

// Глобальная область видимости
const globalVar = "I am global";

function myFunction() {
  // Область видимости функции
  const functionVar = "I am in function";
  
  if (true) {
    // Блочная область видимости
    const blockVar = "I am in block";
    console.log(blockVar); // "I am in block" — доступна
  }
  
  console.log(blockVar); // ReferenceError! — не доступна вне блока
}

console.log(functionVar); // ReferenceError! — не доступна вне функции
console.log(globalVar); // "I am global" — доступна везде

Сравнение с var и let

var — функциональная область видимости

function example() {
  if (true) {
    var oldStyle = "I am var";
  }
  console.log(oldStyle); // "I am var" — доступна! (поднялась на уровень функции)
}

example();
console.log(oldStyle); // ReferenceError! — не доступна вне функции

let — блочная область видимости (как const)

function example() {
  if (true) {
    let modern = "I am let";
  }
  console.log(modern); // ReferenceError! — не доступна вне блока
}

const — блочная область видимости + неизменяемость

function example() {
  if (true) {
    const safe = "I am const";
  }
  console.log(safe); // ReferenceError! — не доступна вне блока
}

Где создаётся блочная область видимости

// 1. Блок if
if (condition) {
  const x = 1; // Область видимости только внутри if
}

// 2. Блок else
else {
  const x = 2; // Другая переменная x с другой областью видимости
}

// 3. Блок switch
switch (value) {
  case 1:
    const x = "one"; // Новая область видимости
    break;
  case 2:
    const x = "two"; // SyntaxError! Нельзя переобъявить в одном switch
}

// 4. Цикл for
for (let i = 0; i < 10; i++) {
  const item = data[i]; // Новая область видимости для каждой итерации
}
console.log(item); // ReferenceError! — не доступна вне цикла

// 5. Цикл while
while (condition) {
  const temp = calculateSomething(); // Область видимости внутри while
}

// 6. Блок try-catch
try {
  const result = riskyOperation();
} catch (error) {
  const message = error.message; // Область видимости только в catch
}

// 7. Просто блок {}
{
  const isolated = "I am isolated";
}
console.log(isolated); // ReferenceError!

Temporal Dead Zone (TDZ)

Одна из отличительных черт const и let — это Temporal Dead Zone. Переменная существует с начала блока, но её нельзя использовать до объявления.

// ReferenceError: Cannot access 'x' before initialization
console.log(x);
const x = 10;

// А с var было бы так:
console.log(y); // undefined (hoisting)
var y = 10;

// Temporal Dead Zone — период от начала блока до объявления
// Это предотвращает случайное использование переменных

Практические примеры

Правильное использование в цикле:

// Неправильно — забыли, что const в цикле пересоздаётся
for (let i = 0; i < 3; i++) {
  const item = items[i];
}
console.log(item); // ReferenceError

// Правильно — понимаете область видимости
const items = [1, 2, 3];
items.forEach((item) => {
  console.log(item); // item доступна только внутри callback'а
});

Область видимости в модулях:

// module.js
const secret = "This is secret"; // Область видимости этого модуля
const public = "Export this";

export { public }; // Только public экспортируется

// Другой файл
import { public } from './module.js';
console.log(secret); // ReferenceError! — не доступна

Избежание ошибок:

// Ошибка — переобъявление в одном блоке
{
  const x = 1;
  const x = 2; // SyntaxError: Identifier 'x' has already been declared
}

// Правильно — разные блоки, разные области видимости
{
  const x = 1;
}
{
  const x = 2; // OK
}

Важные правила

1. const не может быть переобъявлена:

const name = "John";
const name = "Jane"; // SyntaxError!

2. const должна быть инициализирована при объявлении:

const x; // SyntaxError: Missing initializer
const y = undefined; // OK

3. const защищает от переприсваивания, но не от мутации:

const obj = { name: "John" };
obj.name = "Jane"; // OK! — объект мутирован
obj = { name: "Jane" }; // TypeError! — нельзя переприсвоить

const arr = [1, 2, 3];
arr[0] = 99; // OK! — массив мутирован
arr = []; // TypeError! — нельзя переприсвоить

Рекомендации

Используй const по умолчанию:

• Безопаснее всего
• Явно показывает, что переменная не переприсваивается
• Блочная область видимости предотвращает ошибки

Используй let, если нужно переприсвоить:

let counter = 0;
for (let i = 0; i < 10; i++) {
  counter += i;
}

Избегай var в современном коде:

• Функциональная область видимости запутана
• Hoisting приводит к ошибкам
• Используй const/let вместо

Вывод: const имеет блочную область видимости, которая ограничивает доступность переменной только текущим блоком кода. Это делает код более предсказуемым и безопасным, поэтому const должна быть твоим первым выбором в современном JavaScript.