Почему var deprecated?

Почему перестали использовать var в современном JavaScript?

var был оригинальным способом объявления переменных в JavaScript с момента создания языка, но в ES6 (ECMAScript 2015) появились let и const, которые постепенно вытеснили var из современной разработки. Это произошло не просто так, а из-за фундаментальных проблем var, мешающих писать надежный и понятный код.

Ключевые проблемы var

1. Отсутствие блочной области видимости (Function Scope)

Самая критичная проблема — переменные, объявленные через var, имеют область видимости функции или глобальную, но никогда — блочную ({...}).

if (true) {
    var message = "Привет"; // Не ограничена блоком if
    let modernMessage = "Современный привет"; // Ограничена блоком if
}
console.log(message); // "Привет" — переменная доступна!
console.log(modernMessage); // ReferenceError — переменная недоступна

Это приводит к непредсказуемому поведению, особенно в циклах:

for (var i = 0; i < 5; i++) {
    setTimeout(function() {
        console.log(i); // Всегда выведет 5, пять раз
    }, 100);
}
// i доступна и здесь: console.log(i) // 5

С let эта проблема решается, так как каждая итерация цикла получает свою собственную блочную переменную.

2. Поднятие (Hoisting) с инициализацией undefined

И var, и let/const подвергаются поднятию, но с кардинально разным поведением.

console.log(oldVar); // undefined (нет ошибки, но значение undefined)
// Код здесь ведёт себя так, как будто переменная объявлена, но не инициализирована
var oldVar = "Значение";

console.log(newLet); // ReferenceError: Cannot access 'newLet' before initialization
let newLet = "Значение"; // Доступна только после объявления (в "временной мёртвой зоне")

Переменные var поднимаются и автоматически инициализируются значением undefined, что часто маскирует логические ошибки, когда код пытается использовать переменную до её реального объявления.

3. Возможность повторного объявления в той же области видимости

var позволяет множество раз объявлять одну и ту же переменную, что может случайно привести к перезаписи значения.

var user = "Анна";
// ... 100 строк кода ...
var user = "Иван"; // Никакой ошибки! Переменная перезаписана.
console.log(user); // "Иван"

let count = 1;
let count = 2; // SyntaxError: Identifier 'count' has already been declared

const, в свою очередь, не только запрещает повторное объявление, но и не позволяет изменять значение после инициализации (для примитивных типов и ссылки для объектов).

4. Автоматическое присоединение к глобальному объекту (window)

При объявлении var в глобальной области видимости переменная становится свойством глобального объекта (window в браузере).

var globalVar = "Я в window!";
console.log(window.globalVar); // "Я в window!"

let localLet = "Я не в window";
console.log(window.localLet); // undefined

Это может привести к непреднамеренному засорению глобального пространства имён и конфликтам, особенно при интеграции нескольких библиотек.

Почему let и const — это лучше?

• Чёткая область видимости: let и const имеют блочную область видимости, что делает поток данных в программе явным и предсказуемым.
• Контроль над изменяемостью: Использование const по умолчанию сигнализирует о намерениях разработчика и защищает от случайных переприсваиваний. let используется только для переменных, которые действительно будут меняться.
• Избегание скрытых ошибок: Временная мёртвая зона (TDZ) для let/const гарантирует, что переменная не может быть использована до её объявления, помогая отлавливать ошибки на этапе разработки.
• Более чистый код для асинхронных операций: Проблема с циклами и setTimeout, описанная выше, решается элементарно сменой var на let.

Вывод

var сегодня считается устаревшим (deprecated) в контексте написания нового кода. Все современные стили кода (ESLint правила, такие как no-var) и руководства по стилю настоятельно рекомендуют использовать:

• const по умолчанию для всех значений, которые не планируется переназначать.
• let только в тех случаях, когда переменной действительно нужно переназначение.
• var не используется вообще.

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