PrepBro
← Назад к вопросам

Будешь ли использовать var в своих проектах

1.2 Junior🔥 161 комментариев
#JavaScript Core

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI2 апр. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

Будешь ли использовать var в своих проектах?

Нет, я не буду использовать var в своих проектах. Современный стандарт JavaScript предоставляет лучшие альтернативы: let и const. Использование var в 2024+ году считается плохой практикой, и любой профессиональный проект, будь то открытый код или корпоративное приложение, избегает var. Понимание причин этого решения покажет глубокое знание JavaScript и best practices.

Почему var устарел?

1. Функциональный скоп вместо блочного

var имеет функциональный скоп, а не блочный. Это источник множества ошибок:

// ПРОБЛЕМА с var - функциональный скоп
function example() {
  if (true) {
    var x = 10;
  }
  console.log(x); // 10 - x доступна ВНЕ блока if!
  // Это неинтуитивно и опасно
}

function example2() {
  for (var i = 0; i < 5; i++) {
    // i существует только в цикле
  }
  console.log(i); // 5 - i доступна ВНЕ цикла!
  // Это частая ошибка
}

// ПРАВИЛЬНО с let - блочный скоп
function exampleRight() {
  if (true) {
    let y = 10;
  }
  console.log(y); // ReferenceError - y не определена
  // Это ожидаемое поведение
}

function exampleRight2() {
  for (let i = 0; i < 5; i++) {
    // i существует только в цикле
  }
  console.log(i); // ReferenceError - i не определена
  // Правильное поведение
}

Практический пример ошибки с var в цикле

// ПРОБЛЕМА - классическая ошибка с var
const callbacks = [];

for (var i = 0; i < 5; i++) {
  callbacks.push(() => console.log(i));
}

callbacks[0](); // 5 - не 0!
callbacks[1](); // 5 - не 1!
callbacks[4](); // 5
// Почему? Потому что var имеет функциональный скоп,
// и все callbacks ссылаются на одну переменную i

// РЕШЕНИЕ с let
const callbacks2 = [];

for (let i = 0; i < 5; i++) {
  callbacks2.push(() => console.log(i));
}

callbacks2[0](); // 0 - правильно!
callbacks2[1](); // 1 - правильно!
callbacks2[4](); // 4 - правильно!
// let имеет блочный скоп, каждая итерация получает свою переменную

2. Hoisting (всплытие) - неконтролируемое и опасное

var объявления "всплывают" (hoisting) в верх функции, но инициализация не всплывает:

// ПРОБЛЕМА с var - неожиданное hoisting
console.log(x); // undefined (не Error!)
var x = 10;
console.log(x); // 10

// Это эквивалентно:
var x; // Hoisting - объявление
console.log(x); // undefined
x = 10; // Инициализация
console.log(x); // 10

// Это очень опасно и приводит к ошибкам!
function test() {
  if (!user) { // user undefined (hoisting)
    var user = 'John'; // Поздно заметим ошибку
  }
  console.log(user); // Может быть undefined
}

// ПРАВИЛЬНО с let - нет hoisting
console.log(y); // ReferenceError: y is not defined
let y = 10;
// Ошибка сразу же видна и понятна

3. Переименование (redeclaration) разрешено

// ПРОБЛЕМА с var - можно переобъявить
var name = 'John';
var name = 'Jane'; // Разрешено!
var name = 'Bob';  // Разрешено!

// Это опасно в больших файлах - случайно перепишешь переменную
function handleUser() {
  var user = fetchUser();
  // ... 100 строк кода ...
  var user = null; // Случайно переобъявили!
}

// ПРАВИЛЬНО с let - переименование не разрешено
let name2 = 'John';
let name2 = 'Jane'; // SyntaxError: Identifier 'name2' has already been declared
// Ошибка сразу же поймается

4. Глобальное загрязнение (pollution)

// ПРОБЛЕМА с var - создаёт глобальные переменные
function myFunction() {
  var globalVar = 'I am global!';
}

myFunction();
console.log(window.globalVar); // 'I am global!' - попала в глобальный scope!
console.log(globalVar); // Работает везде в коде

// Это очень опасно для больших приложений
var jQuery = 'My jQuery'; // Перезаписали jQuery!

// ПРАВИЛЬНО с let
function myFunction2() {
  let localVar = 'I am local!';
}

myFunction2();
console.log(window.localVar); // undefined
console.log(localVar); // ReferenceError
// let остаётся локальной

Сравнение var, let и const

// VAR - старый способ (ИЗБЕГАТЬ)
var x = 10;
console.log(x); // 10
var x = 20; // Можно переобъявить
x = 30; // Можно переназначить

// Проблемы:
// - Функциональный скоп (не блочный)
// - Hoisting
// - Переименование разрешено
// - Глобальное загрязнение

// LET - переменная значение может меняться (ИСПОЛЬЗУЙ КОГДА НУЖНО МЕНЯТЬ)
let y = 10;
console.log(y); // 10
// let y = 20; // SyntaxError - не можно переобъявить
y = 30; // Разрешено переназначить

for (let i = 0; i < 5; i++) {
  // i существует только в цикле
}
// console.log(i); // ReferenceError

// Преимущества:
// - Блочный скоп
// - Нет hoisting (Temporal Dead Zone)
// - Не можно переименовать
// - Не загрязняет глобальный scope

// CONST - переменная не может меняться (ИСПОЛЬЗУЙ ПО УМОЛЧАНИЮ)
const z = 10;
console.log(z); // 10
// z = 20; // TypeError: Assignment to constant variable
// const z = 20; // SyntaxError

// Важно: const не означает immutable для объектов!
const obj = { name: 'John' };
obj.name = 'Jane'; // Разрешено - меняем свойство
// obj = {}; // TypeError - не можно переназначить сам объект

// Преимущества:
// - Блочный скоп
// - Нет hoisting
// - Не можно переименовать или переназначить
// - Показывает намерение - это значение не меняется
// - Инструменты (linters) лучше оптимизируют const

Best Practices современного JavaScript

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

// ВСЕГДА начинай с const
const userName = 'John';
const userAge = 30;
const users = []; // даже если будешь менять содержимое

const updateUser = (id, data) => {
  // Логика обновления
};

2. Используй let только когда нужно переназначить

// let когда переменная меняет значение
let count = 0;
count++; // Нужен let

let sum = 0;
for (let i = 0; i < 10; i++) {
  sum += i; // Нужен let
}

let retries = 3;
while (retries > 0) {
  try {
    // операция
    retries = 0; // Нужен let
  } catch (e) {
    retries--;
  }
}

3. НИКОГДА не используй var

// НИКОГДА - даже для обратной совместимости
// Если нужна обратная совместимость - используй transpiler (Babel)
var old = 'no'; // ПЛОХО!

// Правильно
const modern = 'yes'; // ХОРОШО

Почему я не буду использовать var в профессиональном проекте?

1. Современный код требует const/let

// Lint rules в любом современном проекте
// eslintrc.json
{
  "rules": {
    "no-var": "error", // ЗАПРЕЩАЕТ var!
    "prefer-const": "warn" // ПРЕДПОЧИТАЕТ const
  }
}

// TypeScript по умолчанию не рекомендует var
// Prettier и другие tools предполагают let/const

2. Все фреймворки используют const/let

// React
function Component() {
  const [count, setCount] = useState(0); // const
  const handleClick = () => setCount(count + 1); // const
  return <button onClick={handleClick}>{count}</button>;
}

// Vue
const { ref, computed } = require('vue');
const count = ref(0);
const doubled = computed(() => count.value * 2);

// Angular
export class Component {
  private readonly items: string[] = []; // const
  constructor(private service: Service) {} // const this
}

3. Лучшая оптимизация с const

// Браузеры и инструменты лучше оптимизируют const
const optimized = () => {
  const config = { timeout: 5000 }; // const - предсказуемо
  // Браузер может встроить это значение (inline)
};

// С let или var браузер должен быть осторожнее
let notOptimized = () => {
  let config = { timeout: 5000 }; // let - может измениться
  // Браузер не может встроить
};

Мой подход в 2024+

// Стандартный паттерн в моих проектах:

// 1. const по умолчанию
const API_BASE_URL = 'https://api.example.com';
const MAX_RETRIES = 3;

// 2. let для значений которые меняются
let retryCount = 0;
while (retryCount < MAX_RETRIES) {
  try {
    await fetch(`${API_BASE_URL}/data`);
    retryCount = MAX_RETRIES; // успех
  } catch (error) {
    retryCount++;
  }
}

// 3. var - НИКОГДА
// var usedToBeHere = 'But not anymore!'; // NO!

// 4. Для объектов - const + mutation
const user = { name: 'John', age: 30 };
user.age = 31; // Разрешено - const не делает объект immutable
user = {}; // TypeError - переназначение не разрешено

// Если нужна полная immutability
const Object.freeze(user);
user.age = 32; // Ошибка в strict mode или молча игнорируется

Практический вывод

В современной разработке:

  • const - 90% времени
  • let - 10% времени
  • var - 0% времени

Это не просто рекомендация, это стандарт. Использование var в 2024+ показывает либо незнание современного JavaScript, либо работу с очень старым кодом. В профессиональном проекте var будет отклонен на code review, и это правильно.

Мой ответ: нет, я не буду использовать var в своих проектах, потому что это плохая практика, опасно, и все современные инструменты, фреймворки и lint rules против этого. Вместо этого я буду следовать лучшим практикам: const по умолчанию, let для изменяемых значений, и полное избежание var.

Будешь ли использовать var в своих проектах | PrepBro