Запах кода в классах JavaScript

Как удалить бесполезный код и упростить структуру кода

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

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

Ленивый или халявный класс

Класс «ленивый» или «халявщик» - это класс, который делает слишком мало. Если он мало что делает, его, вероятно, не стоит добавлять, поскольку он в основном бесполезен.

Мы должны найти способ поместить все, что есть в ленивом классе, в место, где есть больше вещей. Класс, который имеет только один или два метода, вероятно, не слишком полезен.

Чрезмерное использование литералов

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

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

Например, если нам нужно разместить URL-адрес Medium в нескольких местах нашего кода, мы должны иметь одну константу с URL-адресом, а не повторять ее в нескольких местах.

Так что вместо:

const mediumRequest = fetch('http://medium.com');
//...
const mediumJsUrl = 'https://medium.com/topic/javascript';

Вместо этого мы должны написать:

const MEDIUM_URL = 'http://medium.com';
const mediumRequest = fetch(MEDIUM_URL)
//.,.
const mediumJsUrl = `${MEDIUM_URL}/topic/javascript`;

Это лучше, потому что мы не повторяли https://medium.com в нескольких местах. Тогда вносить изменения становится проще.

Цикломатическая сложность

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

Сложность может возникнуть по-разному. Циклы и условные выражения могут быть слишком глубоко вложенными. Более двух уровней вложенности - это, вероятно, слишком много, и их трудно читать.

Также может быть слишком много условных выражений и циклов, которые не являются вложенными.

Например, вместо того, чтобы писать что-то вроде:

Вместо этого мы должны написать:

Мы устранили вложенность и переместили некоторый глубоко вложенный код в его собственную функцию. Это повышает удобочитаемость, а разделение кода на отдельные функции упрощает тестирование.

Кроме того, использование операторов управления циклом, таких как continue и break, в дополнение к return может помочь в большом количестве управления потоком кода без глубокой вложенности условных операторов с большим количеством строк внутри.

Осиротевшая переменная или постоянный класс

Это классы, которые имеют набор констант, которые принадлежат другому, а не их собственному классу.

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

Например, если у нас есть класс со следующей переменной, и у нас есть следующие классы:

Тогда 'red' в классе Color лучше подходит для класса Apple, поскольку мы используем его только для Apple экземпляров.

Вместо этого мы можем написать:

class Apple {
  constructor() {
    this.color = 'red';
  }
}

И не беспокойтесь о классе Color.

Сгусток данных

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

Например, если у нас есть набор переменных, которые мы передаем в функцию следующим образом:

Мы должны переписать это так, чтобы вместо этого все переменные находились в объекте, и изменить сигнатуру функции, чтобы принять объект. Как видим, параметров шесть, это слишком много. Более пяти, вероятно, слишком много параметров для функции в большинстве случаев.

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

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

Мы также часто повторяли слово fruit.

Мы можем исключить все повторения и уменьшить количество переменных и параметров, с которыми нам приходится иметь дело, написав вместо этого следующее:

Теперь у нас есть только один объект и параметр, с которыми нужно работать, вместо нескольких переменных и параметров. Это намного проще для глаз и более организовано. Кроме того, нам труднее забыть ссылаться на некоторые переменные в нашем коде, поскольку нам приходится иметь дело только с одной.

Заключение

У нас не должно быть классов, которые обрабатывают небольшие или бессознательные переменные и константы. Кроме того, слишком много циклов и условий - особенно если они глубоко вложены - трудно читать и следовать.

Если у нас есть много переменных, связанных друг с другом, их следует сгруппировать в объекты, чтобы с ними было легко ссылаться и работать с ними.