Что используется вместо var?

Var, Let и Const: правильный выбор в современном JavaScript

var - это ключевое слово для объявления переменных из ранних версий JavaScript (ES5 и ранее). С появлением ES2015 (ES6) рекомендуется использовать let и const вместо var. За 10+ лет разработки я наблюдал полный отказ от var в профессиональной кодовой базе.

Почему var считается устаревшим

1. Function-scoped vs Block-scoped

var имеет функциональную область видимости, что приводит к неожиданному поведению:

// var: function-scoped (видна везде в функции)
function example() {
  if (true) {
    var x = 1;
  }
  console.log(x); // 1 (утекла из блока if!)
}

// let/const: block-scoped (видна только в блоке)
function example2() {
  if (true) {
    let y = 1;
  }
  console.log(y); // ReferenceError (правильное поведение)
}

Это источник множества ошибок и неожиданного поведения.

2. Hoisting (поднятие/всплытие)

var переменные поднимаются в начало функции и инициализируются как `undefined`:

// var: поднимается и инициализируется undefined
console.log(a); // undefined (не ошибка!)
var a = 5;

// Это работает, но очень запутанно:
if (false) {
  var x = 10; // не выполнится
}
console.log(x); // undefined (поднялось в scope)

// let/const: поднимаются, но не инициализируются (TDZ)
console.log(b); // ReferenceError (Temporal Dead Zone)
let b = 5;

3. Переинициализация в одной области видимости

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

var name = "Иван";
// ... много кода ...
var name = "Петр"; // Переписали случайно!

// let/const защищают от этого:
let count = 0;
let count = 1; // SyntaxError: Identifier count has already been declared

Современный подход: let vs const

let - переменная, которая может измениться

let age = 25;
age = 26; // Можно переассигнить

let name; // Можно объявить без инициализации
name = "Дмитрий";

const - константа, которая не меняется

const PI = 3.14159;
PI = 3.14; // TypeError: Assignment to constant variable

// const НЕ означает "immutable object"
const user = { name: "Дмитрий" };
user.name = "Сергей"; // Можно менять свойства объекта
user = {}; // Но переассигнить нельзя

Правило: "const по умолчанию"

Опытные разработчики используют это правило:

// 1. Сначала const (по умолчанию)
const name = "Alice";
const count = 0;
const config = { timeout: 5000 };

// 2. let только если нужна переассигнация
let age = 25;
age = 26; // Точно нужна переассигнация

// 3. var никогда
// ❌ var oldStyle = true; // Старинный код, избегать!

Примеры из реальной практики:

// ✅ Правильно: const по умолчанию
const users = [];
const api = "https://api.example.com";
const handleClick = () => {};

// Добавляем элементы в массив (это не переассигнация)
users.push({ id: 1, name: "Alice" });

// ✅ Правильно: let для циклов и счётчиков
for (let i = 0; i < 10; i++) {
  console.log(i);
}

// ✅ Правильно: let при действительной переассигнации
let message = "Loading...";
message = "Success!"; // Действительно переассигируем

Почему const лучше для объектов и массивов

Основное преимущество const - это не то, что значение не меняется, а то, что ссылка не меняется. Для работы с массивами и объектами это идеально:

const items = [];
items.push(1);      // ✅ Работает
items[0] = 5;       // ✅ Работает
items = [2, 3];     // ❌ TypeError

const user = { name: "Bob" };
user.age = 30;      // ✅ Работает
user = { name: "Alice" }; // ❌ TypeError

Это защищает от случайной переассигнации, при этом не препятствуя работе с данными внутри структуры.

Практические рекомендации

1. Используй const везде, где нет переассигнации - это первая строчка защиты от ошибок
2. let для счётчиков, временных значений, переменных цикла
3. var никогда - даже в старом коде стараюсь рефакторить на let/const
4. TypeScript дополнительно поймёт ваше намерение и поможет с типизацией

Резюме

Вместо var используют const и let. Это стало стандартом с ES2015 и обязательно в любом современном проекте. Const используется по умолчанию, let - только если нужна переассигнация. Это значительно снижает количество ошибок и делает код более понятным.