Почему не используешь var на нынешней работе?

Почему не используешь var на нынешней работе

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

История: от var к let и const

Когда JavaScript появился в 1995 году, было только var. Но он имел серьёзные недостатки, которые привели к ошибкам:

function example() {
  if (true) {
    var x = 10;
  }
  console.log(x); // 10, а не ошибка!
}

В 2015 году появились let и const (ES6), которые исправили все проблемы var.

Основные проблемы var

1. Function Scope вместо Block Scope

// Проблема: переменная видна за пределами блока
function test() {
  if (true) {
    var x = 10;
  }
  console.log(x); // 10 (неожиданно!)
}

// Правильно: с let
function test() {
  if (true) {
    let x = 10;
  }
  console.log(x); // ReferenceError: x is not defined
}

Это приводит к ошибкам, потому что переменная "утекает" из блока, где она должна быть видна.

2. Hoisting (поднятие)

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

// var: хойстится
console.log(x); // undefined (не ошибка!)
var x = 10;
console.log(x); // 10

// let: временная мертвая зона (TDZ)
console.log(y); // ReferenceError: Cannot access 'y' before initialization
let y = 10;
console.log(y); // 10

С var ты получаешь undefined, вместо ошибки. Это скрывает баги:

// Сложный случай
function process(data) {
  for (var i = 0; i < data.length; i++) {
    setTimeout(() => {
      console.log(i); // Всегда выведет последний i!
    }, 100);
  }
}

// С let работает правильно
function process(data) {
  for (let i = 0; i < data.length; i++) {
    setTimeout(() => {
      console.log(i); // Правильные значения
    }, 100);
  }
}

3. Переопределение переменной

var x = 10;
var x = 20; // Нет ошибки, просто переопределили
console.log(x); // 20

// Это легко допустить ошибку
var name = "Alice";
// ... много кода ...
var name = "Bob"; // Случайно переопределили!

// С let
let name = "Alice";
let name = "Bob"; // SyntaxError: Identifier 'name' has already been declared

4. Загрязнение глобального скопа

// var в глобальном скопе
var globalVar = 10;
console.log(window.globalVar); // 10 (в браузере)

// let в глобальном скопе
let globalLet = 10;
console.log(window.globalLet); // undefined

Это опасно, потому что случайно можно перезаписать глобальные переменные.

Почему let и const лучше

1. Block Scope — переменные живут только в своем блоке

{
  let x = 10;
  const y = 20;
}
console.log(x); // ReferenceError
console.log(y); // ReferenceError

2. Нельзя переопределить

let count = 0;
let count = 1; // SyntaxError

const PI = 3.14;
const PI = 3.14159; // SyntaxError

3. Временная мертвая зона (Temporal Dead Zone)

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

Это помогает ловить ошибки раньше.

4. const по умолчанию

// Лучше практика: используй const для переменных, которые не меняются
const user = { name: "Alice" };
user.name = "Bob"; // Это нормально (меняем содержимое объекта)

const age = 25;
age = 26; // TypeError: Assignment to constant variable

// Если нужно переназначение
let count = 0;
count++; // Нормально

Как это выглядит в реальном коде

Плохо (var):

function getUserData(ids) {
  var users = [];
  
  for (var i = 0; i < ids.length; i++) {
    var userId = ids[i]; // Видна за пределами for!
    var response = fetch(`/api/users/${userId}`); // Видна везде!
    users.push(response);
  }
  
  console.log(userId); // Ошибка! userId "утекла" из цикла
  return users;
}

Хорошо (let/const):

function getUserData(ids) {
  const users = []; // const, потому что не переприсваиваем
  
  for (let i = 0; i < ids.length; i++) {
    const userId = ids[i]; // Block scope
    const response = fetch(`/api/users/${userId}`); // Block scope
    users.push(response);
  }
  
  console.log(userId); // ReferenceError: не существует
  return users;
}

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

Пример 1: Обработка асинхронности

// НЕПРАВИЛЬНО с var
for (var i = 0; i < 3; i++) {
  setTimeout(() => {
    console.log(i); // Выведет: 3, 3, 3
  }, 100);
}

// ПРАВИЛЬНО с let
for (let i = 0; i < 3; i++) {
  setTimeout(() => {
    console.log(i); // Выведет: 0, 1, 2
  }, 100);
}

Пример 2: Условное объявление

// НЕПРАВИЛЬНО с var
function process(condition) {
  if (condition) {
    var result = "success";
  } else {
    var result = "failed"; // Переопределение!
  }
  console.log(result); // Видна везде
}

// ПРАВИЛЬНО с let
function process(condition) {
  let result;
  if (condition) {
    result = "success";
  } else {
    result = "failed";
  }
  console.log(result);
}

Стандарты в современных проектах

В 2026 году это явно определено в code style гайдах:

ESLint правила:
"no-var": "error"       // Запретить var
"prefer-const": "warn"  // Рекомендовать const
"prefer-let": "warn"   // Использовать let вместо const, если нужна переприсвязь

Почти все компании имеют эти правила в своих проектах. Использование var просто не пройдет code review.

Что ответить на собеседовании

Структурированный ответ:

1. Главная причина: var имеет function scope вместо block scope, что приводит к ошибкам
2. Hoisting: var поднимается, но не инициализируется, скрывая баги
3. Переопределение: var позволяет случайно переопределить переменную
4. let/const: Имеют block scope, TDZ, не позволяют переопределить
5. Практика: Используем const по умолчанию, let когда нужна переприсвязь
6. Инструменты: ESLint запрещает var на всех проектах

Заключение

var — это историческая ошибка JavaScript, которую исправили в 2015 году с ES6. На нынешней работе не используется var потому что:

• Это приводит к ошибкам и непредсказуемому поведению
• let и const решают все проблемы и более удобны
• Все инструменты (ESLint, TypeScript, IDE) рекомендуют их
• Это best practice в 2026 году

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