Глава 12 книги «Чистый код», озаглавленная «Появление», исследует, как чистое, хорошо структурированное программное обеспечение возникает в результате соблюдения фундаментальных принципов проектирования.

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

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

В этой главе основное внимание уделяется четырем правилам простого дизайна, в которых особое внимание уделяется простоте и тестируемости чистого и эффективного кода.

? Четыре правила простого дизайна

• Проходит все тесты
• Раскрывает намерение
• Без дублирования
• Минимизирует количество классов и методов

Давайте разберем каждое из этих правил и посмотрим, как они применяются с использованием JavaScript.

1. Проходит все тесты

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

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

В JavaScript это часто достигается путем написания модульных тестов с использованием таких библиотек, как Jest или Mocha.

function add(a, b) {
  return a   b;
}

// Test (using Jest)
test('adds 1   2 to equal 3', () => {
  expect(add(1, 2)).toBe(3);
});

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

Чистый код начинается с надежных тестов. Без этого никакие другие правила не имеют значения.

2. Раскрывает намерение

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

Код, раскрывающий его назначение, не требует пояснений.

Неправильное именование:

function d(x) {
  return x * 2;
}

Хорошее имя:

function doubleNumber(number) {
  return number * 2;
}

В этом случае doubleNumber() ясно раскрывает назначение функции.

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

Такая практика не только уменьшает путаницу, но и улучшает удобство обслуживания.

3. Никакого дублирования

Дублирование кода — один из главных врагов чистого программного обеспечения. Повторяющаяся логика может привести к ошибкам и увеличению затрат на обслуживание.

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

Дублирование кода:

function calculateAreaOfSquare(side) {
  return side * side;
}

function calculateAreaOfRectangle(length, width) {
  return length * width;
}

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

Без дублирования:

function calculateArea(shape) {
  if (shape.type === 'square') {
    return shape.side * shape.side;
  } else if (shape.type === 'rectangle') {
    return shape.length * shape.width;
  }
}

Обобщая функцию, мы устраняем повторяющуюся логику и делаем код более удобным в сопровождении.

4. Минимизирует количество классов и методов.

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

Это значит избегать ненужной сложности.

Каждый класс или функция должны иметь четкую и целенаправленную ответственность в соответствии с принципом единой ответственности (SRP).

Слишком много методов:

class User {
  constructor(name) {
    this.name = name;
  }

  getName() {
    return this.name;
  }

  setName(name) {
    this.name = name;
  }

  printWelcomeMessage() {
    console.log(`Welcome, ${this.name}!`);
  }

  // Additional unrelated methods
  getUserProfile() {
    // ... some logic
  }

  logActivity() {
    // ... some logic
  }
}

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

Рефакторинг:

class User {
  constructor(name) {
    this.name = name;
  }

  getName() {
    return this.name;
  }

  setName(name) {
    this.name = name;
  }
}

class Logger {
  static logActivity(user) {
    // ... some logic
    console.log(`${user.getName()} performed an activity.`);
  }
}

Разделение задач упрощает код и упрощает его поддержку.

Теперь каждый класс несет единую ответственность, придерживаясь принципов минимализма и простоты.

Заключение

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

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

Удачного программирования!