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

Чистый код. Глава 10 подчеркивает важность сплоченных классов с единой ответственностью.

В этой статье мы поделимся ключевыми идеями и продемонстрируем их применение в JavaScript.

? Что такое классовая сплоченность?

Сплоченность означает, насколько тесно связаны обязанности класса.

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

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

Пример: низкая сплоченность

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

  // Handles user registration
  register() {
    // Registration logic
  }

  // Sends email to user
  sendEmail(message) {
    // Email sending logic
  }

  // Logs activity of the user
  logActivity(activity) {
    console.log(`${this.name} performed: ${activity}`);
  }
}

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

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

? Принцип единой ответственности (SRP)

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

Если у класса более одной ответственности, изменения в одной области могут нарушить функциональность другой.

⚡️ Рефакторинг для SRP

Давайте переработаем приведенный выше пример, чтобы он соответствовал SRP:

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

class UserRegistrationService {
  register(user) {
    // Registration logic
  }
}

class EmailService {
  sendEmail(user, message) {
    // Email sending logic
  }
}

class ActivityLogger {
  logActivity(user, activity) {
    console.log(`${user.name} performed: ${activity}`);
  }
}

Теперь у каждого класса есть одна обязанность:

• Пользователь: представляет объект пользователя и содержит данные.
• UserRegistrationService: обрабатывает регистрацию пользователей.
• EmailService: обрабатывает отправку электронных писем.
• ActivityLogger: занимается регистрацией активности пользователей.

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

? Преимущества SRP и сплоченности

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

• Масштабируемость: По мере роста вашего проекта соблюдение SRP упрощает добавление новых функций. Новые функции можно добавлять в новые классы, не затрагивая существующие.

• Тестируемость: Классы с одной ответственностью легче тестировать. Каждый класс имеет ограниченную область применения, поэтому модульные тесты могут сосредоточиться на отдельных частях функциональности.

? Выявление дублирования ответственности

Чтобы обеспечить сплоченность занятий, ищите области, в которых совмещаются несколько обязанностей.

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

Пример: рефакторинг платежной системы

Предположим, у нас есть класс PaymentProcessor, который обрабатывает несколько задач:

class PaymentProcessor {
  constructor() {
    this.paymentGateway = new PaymentGateway();
  }

  processPayment(paymentDetails) {
    // Payment processing logic
  }

  validatePaymentDetails(paymentDetails) {
    // Validation logic
  }

  logTransaction(paymentDetails) {
    console.log(`Payment processed: ${JSON.stringify(paymentDetails)}`);
  }
}

Здесь PaymentProcessor отвечает за обработку платежей, проверку данных и регистрацию транзакций.

Это возможность провести рефакторинг и разделить обязанности:

class PaymentProcessor {
  constructor(paymentGateway, validator, logger) {
    this.paymentGateway = paymentGateway;
    this.validator = validator;
    this.logger = logger;
  }

  processPayment(paymentDetails) {
    if (this.validator.isValid(paymentDetails)) {
      this.paymentGateway.process(paymentDetails);
      this.logger.logTransaction(paymentDetails);
    }
  }
}

class PaymentValidator {
  isValid(paymentDetails) {
    // Validation logic
    return true; // Simplified for example
  }
}

class PaymentLogger {
  logTransaction(paymentDetails) {
    console.log(`Payment processed: ${JSON.stringify(paymentDetails)}`);
  }
}

Теперь класс PaymentProcessor несет единственную ответственность: обработку платежей.

Проверка и ведение журнала вынесены в отдельные классы (PaymentValidator и PaymentLogger).

⚡️Вывод

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

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

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

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

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