Правила для переменных

Объявление переменных и дисциплина области видимости

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

Современный код предполагает использование let и const вместо устаревшего var, поскольку последние создают функциональную область видимости и подвержены всплытию (hoisting) с неожиданным поведением. В контексте ESLint это контролируется набором правил, ограничивающих некорректные объявления и использование переменных.

Запрет использования несуществующих переменных

Одним из базовых правил является контроль обращения к переменным, которые не были объявлены.

Правило no-undef отслеживает использование идентификаторов, отсутствующих в текущей области видимости.

Типичные ошибки:

  • опечатки в имени переменной;
  • обращение к глобальным объектам без явного объявления;
  • использование переменной до импорта или объявления.

Пример проблемного кода:

console.log(userName); // userName не объявлена

ESLint фиксирует такие случаи как потенциальные ReferenceError в рантайме.

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

Неиспользуемые переменные и «мёртвый код»

Правило no-unused-vars контролирует наличие объявленных, но не используемых переменных.

Подобные ситуации возникают при:

  • частичном рефакторинге;
  • забытых временных переменных;
  • ошибках при деструктуризации;
  • избыточных параметрах функций.

Пример:

const result = computeValue();
// переменная result нигде не используется

Неиспользуемые переменные ухудшают читаемость и создают ложное впечатление о логике программы. В крупных кодовых базах они также увеличивают когнитивную нагрузку при анализе кода.

ESLint позволяет тонко настраивать это правило:

  • игнорирование аргументов функций (argsIgnorePattern);
  • исключение переменных, начинающихся с _;
  • контроль только используемых в пределах файла или проекта.

Использование переменной до объявления

Правило no-use-before-define ограничивает обращение к переменным до их объявления в коде.

Хотя JavaScript допускает hoisting для var, функций и частично для let/const (в виде временной мёртвой зоны), такая практика часто приводит к неочевидным ошибкам.

Пример проблемного поведения:

console.log(value);
const value = 10;

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

В конфигурации правило может учитывать:

  • функции;
  • классы;
  • переменные let и const.

Предпочтение неизменяемых ссылок

Правило prefer-const направлено на снижение количества изменяемых переменных.

Если переменная объявлена через let, но фактически не переопределяется, ESLint предлагает заменить её на const.

Пример:

let count = 10;
console.log(count);

После анализа:

const count = 10;
console.log(count);

Использование const:

  • повышает предсказуемость кода;
  • снижает риск случайного изменения значения;
  • улучшает оптимизацию в некоторых движках.

Запрет повторного объявления переменных

Правило no-redeclare предотвращает повторное объявление одной и той же переменной в одной области видимости.

Пример ошибки:

let value = 1;
let value = 2;

Такие ситуации часто возникают:

  • при слиянии кусков кода;
  • при копировании логики;
  • при отсутствии контроля за неймингом.

В строгом режиме ECMAScript повторное объявление приводит к ошибке, но ESLint выявляет проблему ещё до выполнения кода.

Перекрытие переменных и теневое объявление

Правило no-shadow отслеживает случаи, когда внутренняя переменная перекрывает переменную из внешней области видимости.

Пример:

const id = 10;

function getId() {
  const id = 20;
  return id;
}

Хотя код корректен синтаксически, он снижает читаемость и может вводить в заблуждение при анализе логики.

Особенно опасны такие случаи в:

  • вложенных функциях;
  • callback-обработчиках;
  • замыканиях.

ESLint позволяет ограничивать теневое перекрытие для глобальных переменных и параметров функций.

Именование переменных и стиль идентификаторов

Хотя ESLint не навязывает один стиль именования, правила camelcase и связанные с ним проверки часто применяются для обеспечения единообразия.

camelcase ограничивает использование имен в стиле snake_case в пользу camelCase.

Примеры:

const user_name = 'John'; // нарушение
const userName = 'John';  // корректно

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

Ограничение длины и читаемости идентификаторов

Правило id-length контролирует минимальную и максимальную длину имён переменных.

Слишком короткие имена:

let a = 10;

Слишком длинные:

let numberOfActiveUserSessionsCurrentlyRunning = 5;

Цель правила — баланс между краткостью и выразительностью. В типичных конфигурациях допускаются односимвольные переменные в счетчиках циклов, но запрещаются в бизнес-логике.

Инициализация переменных

Некоторые конфигурации ESLint используют правило init-declarations, требующее или запрещающее объявление переменных без начального значения.

Пример контроля:

let value; // может быть запрещено

Или наоборот:

let value = 0; // предпочтительно

Такой подход уменьшает количество undefined в коде и делает состояние переменных более предсказуемым.

Константы и неизменяемые структуры

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

Пример:

const config = { port: 3000 };
config.port = 4000;

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

Глобальные переменные и область применения

Работа с глобальными переменными регулируется через конфигурацию окружений ESLint (env) и правило no-undef.

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

В современных проектах предпочтение отдается:

  • явным импортам;
  • модульной структуре;
  • минимизации глобального состояния.

Деструктуризация и корректность использования переменных

ESLint также анализирует переменные, полученные через деструктуризацию.

Пример:

const { name, age } = user;

Правило no-unused-vars проверяет каждую часть деструктурированной структуры. Если age не используется, это будет зафиксировано как проблема.

Расширенные настройки позволяют игнорировать определённые поля, если они используются косвенно или передаются дальше без явного обращения.

Параметры функций как переменные

Параметры функций рассматриваются как локальные переменные и подпадают под те же правила:

  • no-unused-vars отслеживает неиспользуемые параметры;
  • no-shadow предотвращает перекрытие;
  • no-use-before-define может учитывать функции высшего порядка.

Пример:

function handler(event, data) {
  return event.id;
}

Если data не используется, ESLint зафиксирует предупреждение, если это не исключено конфигурацией.

Согласованность переменных в кодовой базе

Комплексное использование правил для переменных направлено не только на устранение ошибок, но и на формирование единого стиля работы с данными:

  • предсказуемые области видимости;
  • отсутствие скрытых зависимостей;
  • минимизация неиспользуемых сущностей;
  • строгий контроль именования;
  • предотвращение логических конфликтов.

ESLint в этом контексте выступает как статический анализатор, формирующий структуру кода ещё до выполнения, снижая вероятность ошибок, связанных с переменными на раннем этапе разработки.

Оглавление