Абстрактні класи TypeScript: Опанування патернів часткової реалізації

Абстрактні класи є фундаментальною концепцією в об'єктно-орієнтованому програмуванні (ООП), що надає шаблон для інших класів. У TypeScript абстрактні класи пропонують потужний механізм для визначення спільної функціональності, водночас вимагаючи від похідних класів реалізації певних вимог. Ця стаття заглиблюється в тонкощі абстрактних класів TypeScript, зосереджуючись на практичних патернах часткової реалізації, та на тому, як вони можуть значно покращити повторне використання коду, супровід та гнучкість у ваших проєктах.

Що таке абстрактні класи?

Абстрактний клас у TypeScript — це клас, який не можна інстанціювати безпосередньо. Він слугує базовим класом для інших класів, визначаючи набір властивостей та методів, які похідні класи повинні реалізувати (або перевизначити). Абстрактні класи оголошуються за допомогою ключового слова abstract.

Ключові характеристики:

Не можна інстанціювати безпосередньо.
Можуть містити абстрактні методи (методи без реалізації).
Можуть містити конкретні методи (методи з реалізацією).
Похідні класи повинні реалізовувати всі абстрактні методи.

Навіщо використовувати абстрактні класи?

Абстрактні класи пропонують кілька переваг у розробці програмного забезпечення:

Повторне використання коду: Забезпечують спільну основу для пов'язаних класів, зменшуючи дублювання коду.
Примусова структура: Гарантують, що похідні класи дотримуються певного інтерфейсу та поведінки.
Поліморфізм: Дозволяють розглядати похідні класи як екземпляри абстрактного класу.
Абстракція: Приховують деталі реалізації та надають доступ лише до основного інтерфейсу.

Базовий приклад абстрактного класу

Почнемо з простого прикладу, щоб проілюструвати базовий синтаксис абстрактного класу в TypeScript:


abstract class Animal {
 abstract makeSound(): string;

 move(): void {
 console.log("Moving...");
 }
}

class Dog extends Animal {
 makeSound(): string {
 return "Woof!";
 }
}

class Cat extends Animal {
 makeSound(): string {
 return "Meow!";
 }
}

//const animal = new Animal(); // Помилка: Неможливо створити екземпляр абстрактного класу.

const dog = new Dog();
console.log(dog.makeSound()); // Вивід: Woof!
dog.move(); // Вивід: Moving...

const cat = new Cat();
console.log(cat.makeSound()); // Вивід: Meow!
cat.move(); // Вивід: Moving...

У цьому прикладі Animal — це абстрактний клас з абстрактним методом makeSound() та конкретним методом move(). Класи Dog та Cat розширюють Animal і надають конкретні реалізації для методу makeSound(). Зауважте, що спроба безпосередньо інстанціювати `Animal` призводить до помилки.

Патерни часткової реалізації

Однією з потужних особливостей абстрактних класів є можливість визначати часткові реалізації. Це дозволяє вам надавати реалізацію за замовчуванням для деяких методів, водночас вимагаючи від похідних класів реалізувати інші. Це балансує між повторним використанням коду та гнучкістю.

1. Абстрактні методи з реалізаціями за замовчуванням у похідних класах

У цьому патерні абстрактний клас оголошує абстрактний метод, який *повинен* бути реалізований похідними класами, але не пропонує базової реалізації. Це змушує похідні класи надавати власну логіку.


abstract class DataProcessor {
 abstract fetchData(): Promise;
 abstract processData(data: any): any;
 abstract saveData(processedData: any): Promise;

 async run(): Promise {
 const data = await this.fetchData();
 const processedData = this.processData(data);
 await this.saveData(processedData);
 }
}

class APIProcessor extends DataProcessor {
 async fetchData(): Promise {
 // Реалізація для отримання даних з API
 console.log("Fetching data from API...");
 return { data: "API Data" }; // Імітація даних
 }

 processData(data: any): any {
 // Реалізація для обробки даних, специфічних для API
 console.log("Processing API data...");
 return { processed: data.data + " - Processed" }; // Імітація оброблених даних
 }

 async saveData(processedData: any): Promise {
 // Реалізація для збереження оброблених даних у базу даних через API
 console.log("Saving processed API data...");
 console.log(processedData);
 }
}

const apiProcessor = new APIProcessor();
apiProcessor.run();

У цьому прикладі абстрактний клас DataProcessor визначає три абстрактні методи: fetchData(), processData() та saveData(). Клас APIProcessor розширює DataProcessor і надає конкретні реалізації для кожного з цих методів. Метод run(), визначений в абстрактному класі, організовує весь процес, гарантуючи, що кожен крок виконується в правильному порядку.

2. Конкретні методи з абстрактними залежностями

Цей патерн включає конкретні методи в абстрактному класі, які покладаються на абстрактні методи для виконання певних завдань. Це дозволяє вам визначити загальний алгоритм, делегуючи деталі реалізації похідним класам.


abstract class PaymentProcessor {
 abstract validatePaymentDetails(paymentDetails: any): boolean;
 abstract chargePayment(paymentDetails: any): Promise;
 abstract sendConfirmationEmail(paymentDetails: any): Promise;

 async processPayment(paymentDetails: any): Promise {
 if (!this.validatePaymentDetails(paymentDetails)) {
 console.error("Invalid payment details.");
 return false;
 }

 const chargeSuccessful = await this.chargePayment(paymentDetails);
 if (!chargeSuccessful) {
 console.error("Payment failed.");
 return false;
 }

 await this.sendConfirmationEmail(paymentDetails);
 console.log("Payment processed successfully.");
 return true;
 }
}

class CreditCardPaymentProcessor extends PaymentProcessor {
 validatePaymentDetails(paymentDetails: any): boolean {
 // Валідація даних кредитної картки
 console.log("Validating credit card details...");
 return true; // Імітація валідації
 }

 async chargePayment(paymentDetails: any): Promise {
 // Списання коштів з кредитної картки
 console.log("Charging credit card...");
 return true; // Імітація списання
 }

 async sendConfirmationEmail(paymentDetails: any): Promise {
 // Надсилання листа-підтвердження для оплати кредитною карткою
 console.log("Sending confirmation email for credit card payment...");
 }
}

const creditCardProcessor = new CreditCardPaymentProcessor();
creditCardProcessor.processPayment({ cardNumber: "1234-5678-9012-3456", expiryDate: "12/24", cvv: "123", amount: 100 });

У цьому прикладі абстрактний клас PaymentProcessor визначає метод processPayment(), який обробляє загальну логіку обробки платежів. Однак методи validatePaymentDetails(), chargePayment() та sendConfirmationEmail() є абстрактними, що вимагає від похідних класів надання конкретних реалізацій для кожного способу оплати (наприклад, кредитна картка, PayPal тощо).

3. Патерн "Шаблонний метод"

Патерн "Шаблонний метод" — це поведінковий патерн проєктування, який визначає скелет алгоритму в абстрактному класі, але дозволяє підкласам перевизначати певні кроки алгоритму, не змінюючи його структуру. Цей патерн особливо корисний, коли у вас є послідовність операцій, які повинні виконуватися в певному порядку, але реалізація деяких операцій може змінюватися залежно від контексту.


abstract class ReportGenerator {
 abstract generateHeader(): string;
 abstract generateBody(): string;
 abstract generateFooter(): string;

 generateReport(): string {
 const header = this.generateHeader();
 const body = this.generateBody();
 const footer = this.generateFooter();

 return `${header}\n${body}\n${footer}`;
 }
}

class PDFReportGenerator extends ReportGenerator {
 generateHeader(): string {
 return "PDF Report Header";
 }

 generateBody(): string {
 return "PDF Report Body";
 }

 generateFooter(): string {
 return "PDF Report Footer";
 }
}

class CSVReportGenerator extends ReportGenerator {
 generateHeader(): string {
 return "CSV Report Header";
 }

 generateBody(): string {
 return "CSV Report Body";
 }

 generateFooter(): string {
 return "CSV Report Footer";
 }
}

const pdfReportGenerator = new PDFReportGenerator();
console.log(pdfReportGenerator.generateReport());

const csvReportGenerator = new CSVReportGenerator();
console.log(csvReportGenerator.generateReport());

Тут `ReportGenerator` визначає загальний процес генерації звіту в `generateReport()`, тоді як окремі кроки (заголовок, тіло, нижній колонтитул) залишені для конкретних підкласів `PDFReportGenerator` та `CSVReportGenerator`.

4. Абстрактні властивості

Абстрактні класи також можуть визначати абстрактні властивості, які є властивостями, що повинні бути реалізовані в похідних класах. Це корисно для забезпечення наявності певних елементів даних у похідних класах.


abstract class Configuration {
 abstract apiKey: string;
 abstract apiUrl: string;

 getFullApiUrl(): string {
 return `${this.apiUrl}/${this.apiKey}`;
 }
}

class ProductionConfiguration extends Configuration {
 apiKey: string = "prod_api_key";
 apiUrl: string = "https://api.example.com/prod";
}

class DevelopmentConfiguration extends Configuration {
 apiKey: string = "dev_api_key";
 apiUrl: string = "http://localhost:3000/dev";
}

const prodConfig = new ProductionConfiguration();
console.log(prodConfig.getFullApiUrl()); // Вивід: https://api.example.com/prod/prod_api_key

const devConfig = new DevelopmentConfiguration();
console.log(devConfig.getFullApiUrl()); // Вивід: http://localhost:3000/dev/dev_api_key

У цьому прикладі абстрактний клас Configuration визначає дві абстрактні властивості: apiKey та apiUrl. Класи ProductionConfiguration та DevelopmentConfiguration розширюють Configuration і надають конкретні значення для цих властивостей.

Додаткові аспекти

Міксини з абстрактними класами

TypeScript дозволяє поєднувати абстрактні класи з міксинами для створення більш складних та повторно використовуваних компонентів. Міксини — це спосіб побудови класів шляхом композиції менших, повторно використовуваних частин функціональності.


// Визначаємо тип для конструктора класу
type Constructor = new (...args: any[]) => T;

// Визначаємо функцію-міксин
function Timestamped(Base: TBase) {
 return class extends Base {
 timestamp = new Date();
 };
}

// Ще одна функція-міксин
function Logged(Base: TBase) {
 return class extends Base {
 log(message: string) {
 console.log(`${this.constructor.name}: ${message}`);
 }
 };
}

abstract class BaseEntity {
 abstract id: number;
}

// Застосовуємо міксини до абстрактного класу BaseEntity
const TimestampedEntity = Timestamped(BaseEntity);
const LoggedEntity = Logged(TimestampedEntity);

class User extends LoggedEntity {
 id: number = 123;
 name: string = "John Doe";

 constructor() {
 super();
 this.log("User created");
 }
}

const user = new User();
console.log(user.id); // Вивід: 123
console.log(user.timestamp); // Вивід: Поточна часова мітка
user.log("User updated"); // Вивід: User: User updated

Цей приклад поєднує міксини Timestamped та Logged з абстрактним класом BaseEntity для створення класу User, який успадковує функціональність усіх трьох.

Впровадження залежностей

Абстрактні класи можна ефективно використовувати з впровадженням залежностей (DI) для роз'єднання компонентів та покращення можливості тестування. Ви можете визначати абстрактні класи як інтерфейси для ваших залежностей, а потім впроваджувати конкретні реалізації у ваші класи.


abstract class Logger {
 abstract log(message: string): void;
}

class ConsoleLogger extends Logger {
 log(message: string): void {
 console.log(`[Console]: ${message}`);
 }
}

class FileLogger extends Logger {
 log(message: string): void {
 // Реалізація для запису логів у файл
 console.log(`[File]: ${message}`);
 }
}

class AppService {
 private logger: Logger;

 constructor(logger: Logger) {
 this.logger = logger;
 }

 doSomething() {
 this.logger.log("Doing something...");
 }
}

// Впроваджуємо ConsoleLogger
const consoleLogger = new ConsoleLogger();
const appService1 = new AppService(consoleLogger);
appService1.doSomething();

// Впроваджуємо FileLogger
const fileLogger = new FileLogger();
const appService2 = new AppService(fileLogger);
appService2.doSomething();

У цьому прикладі клас AppService залежить від абстрактного класу Logger. Конкретні реалізації (ConsoleLogger, FileLogger) впроваджуються під час виконання, що дозволяє легко перемикатися між різними стратегіями логування.

Найкращі практики

Зберігайте сфокусованість абстрактних класів: Кожен абстрактний клас повинен мати чітку та добре визначену мету.
Уникайте надмірної абстракції: Не створюйте абстрактні класи, якщо вони не надають значної цінності з точки зору повторного використання коду або примусової структури.
Використовуйте абстрактні класи для основної функціональності: Розміщуйте спільну логіку та алгоритми в абстрактних класах, делегуючи конкретні реалізації похідним класам.
Ретельно документуйте абстрактні класи: Чітко документуйте мету абстрактного класу та обов'язки похідних класів.
Розгляньте можливість використання інтерфейсів: Якщо вам потрібно лише визначити контракт без будь-якої реалізації, розгляньте використання інтерфейсів замість абстрактних класів.

Висновок

Абстрактні класи TypeScript — це потужний інструмент для створення надійних та супроводжуваних застосунків. Розуміючи та застосовуючи патерни часткової реалізації, ви можете використовувати переваги абстрактних класів для створення гнучкого, повторно використовуваного та добре структурованого коду. Від визначення абстрактних методів з реалізаціями за замовчуванням до використання абстрактних класів з міксинами та впровадженням залежностей, можливості величезні. Дотримуючись найкращих практик та ретельно обмірковуючи свої проєктні рішення, ви можете ефективно використовувати абстрактні класи для підвищення якості та масштабованості ваших проєктів на TypeScript.

Незалежно від того, чи створюєте ви великомасштабний корпоративний застосунок або невелику службову бібліотеку, опанування абстрактних класів у TypeScript, безсумнівно, покращить ваші навички розробки програмного забезпечення та дозволить створювати більш складні та супроводжувані рішення.