TypeScript abstrakčiosios klasės: dalinio įgyvendinimo šablonų įsisavinimas

Abstrakčiosios klasės yra pagrindinė objektinio programavimo (OOP) sąvoka, suteikianti šabloną kitoms klasėms. „TypeScript“ abstrakčiosios klasės siūlo galingą mechanizmą, leidžiantį apibrėžti bendrą funkcionalumą ir kartu priversti išvestines klases laikytis konkrečių įgyvendinimo reikalavimų. Šiame straipsnyje gilinamasi į „TypeScript“ abstrakčiųjų klasių subtilybes, daugiausia dėmesio skiriant praktiniams dalinio įgyvendinimo šablonams ir tam, kaip jie gali žymiai pagerinti kodo pakartotinį panaudojamumą, palaikomumą ir lankstumą jūsų projektuose.

Kas yra abstrakčiosios klasės?

Abstrakčioji klasė „TypeScript“ kalboje yra klasė, kurios negalima tiesiogiai sukurti (instancijuoti). Ji veikia kaip bazinė klasė kitoms klasėms, apibrėždama savybių ir metodų rinkinį, kurį išvestinės klasės privalo įgyvendinti (arba perrašyti). Abstrakčiosios klasės deklaruojamos naudojant abstract raktinį žodį.

Pagrindinės savybės:

Negalima tiesiogiai sukurti jų egzempliorių.
Gali turėti abstrakčių metodų (metodų be implementacijos).
Gali turėti konkrečių metodų (metodų su implementacija).
Išvestinės klasės privalo įgyvendinti visus abstrakčius metodus.

Kodėl verta naudoti abstrakčiąsias klases?

Abstrakčiosios klasės programinės įrangos kūrime suteikia keletą privalumų:

Kodo pakartotinis panaudojamumas: Suteikia bendrą pagrindą susijusioms klasėms, mažindamos kodo dubliavimą.
Priverstinė struktūra: Užtikrina, kad išvestinės klasės laikytųsi konkrečios sąsajos ir elgsenos.
Polimorfizmas: Leidžia išvestines klases traktuoti kaip abstrakčiosios klasės egzempliorius.
Abstrakcija: Paslepia implementacijos detales ir atidengia tik esminę sąsają.

Pagrindinis abstrakčiosios klasės pavyzdys

Pradėkime nuo paprasto pavyzdžio, kuris iliustruoja pagrindinę abstrakčiosios klasės sintaksę „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(); // Error: Cannot create an instance of an abstract class.

const dog = new Dog();
console.log(dog.makeSound()); // Output: Woof!
dog.move(); // Output: Moving...

const cat = new Cat();
console.log(cat.makeSound()); // Output: Meow!
cat.move(); // Output: Moving...

Šiame pavyzdyje Animal yra abstrakčioji klasė su abstrakčiu metodu makeSound() ir konkrečiu metodu move(). Klasės Dog ir Cat praplečia Animal klasę ir pateikia konkrečias makeSound() metodo implementacijas. Atkreipkite dėmesį, kad bandant tiesiogiai sukurti Animal egzempliorių, įvyks klaida.

Dalinės implementacijos šablonai

Vienas iš galingų abstrakčiųjų klasių aspektų yra galimybė apibrėžti dalines implementacijas. Tai leidžia jums pateikti numatytąją implementaciją kai kuriems metodams, o kitus reikalauti įgyvendinti išvestinėse klasėse. Taip suderinamas kodo pakartotinis panaudojamumas ir lankstumas.

1. Abstraktūs metodai, kuriuos privaloma įgyvendinti išvestinėse klasėse

Pagal šį šabloną, abstrakčioji klasė deklaruoja abstraktų metodą, kurį *privalo* įgyvendinti išvestinės klasės, tačiau nepateikia jokios bazinės implementacijos. Tai priverčia išvestines klases pateikti savo logiką.


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 {
 // Implementation to fetch data from an API
 console.log("Fetching data from API...");
 return { data: "API Data" }; // Mock data
 }

 processData(data: any): any {
 // Implementation to process data specific to API data
 console.log("Processing API data...");
 return { processed: data.data + " - Processed" }; // Mock processed data
 }

 async saveData(processedData: any): Promise {
 // Implementation to save processed data to a database via API
 console.log("Saving processed API data...");
 console.log(processedData);
 }
}

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

Šiame pavyzdyje abstrakčioji klasė DataProcessor apibrėžia tris abstrakčius metodus: fetchData(), processData() ir saveData(). Klasė APIProcessor praplečia DataProcessor ir pateikia konkrečias kiekvieno iš šių metodų implementacijas. Metodas run(), apibrėžtas abstrakčiojoje klasėje, organizuoja visą procesą, užtikrindamas, kad kiekvienas žingsnis būtų vykdomas teisinga tvarka.

2. Konkretūs metodai su abstračiais priklausomumais

Šis šablonas apima konkrečius metodus abstrakčiojoje klasėje, kurie remiasi abstrakčiais metodais atliekant konkrečias užduotis. Tai leidžia jums apibrėžti bendrą algoritmą, deleguojant implementacijos detales išvestinėms klasėms.


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 {
 // Validate credit card details
 console.log("Validating credit card details...");
 return true; // Mock validation
 }

 async chargePayment(paymentDetails: any): Promise {
 // Charge credit card
 console.log("Charging credit card...");
 return true; // Mock charge
 }

 async sendConfirmationEmail(paymentDetails: any): Promise {
 // Send confirmation email for credit card payment
 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 });

Šiame pavyzdyje abstrakčioji klasė PaymentProcessor apibrėžia metodą processPayment(), kuris tvarko bendrą mokėjimo apdorojimo logiką. Tačiau metodai validatePaymentDetails(), chargePayment() ir sendConfirmationEmail() yra abstraktūs, reikalaujantys, kad išvestinės klasės pateiktų konkrečias implementacijas kiekvienam mokėjimo būdui (pvz., kredito kortele, „PayPal“ ir t.t.).

3. Šablono metodo (Template Method) šablonas

Šablono metodas (Template Method) yra elgsenos projektavimo šablonas, kuris apibrėžia algoritmo skeletą abstrakčiojoje klasėje, bet leidžia poklasiams perrašyti konkrečius algoritmo žingsnius nekeičiant jo struktūros. Šis šablonas ypač naudingas, kai turite operacijų seką, kuri turi būti atlikta tam tikra tvarka, tačiau kai kurių operacijų įgyvendinimas gali skirtis priklausomai nuo konteksto.


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());

Šiuo atveju, ReportGenerator apibrėžia bendrą ataskaitos generavimo procesą metode generateReport(), o atskiri žingsniai (antraštė, turinys, poraštė) paliekami konkretiems poklasiams PDFReportGenerator ir CSVReportGenerator.

4. Abstrakčiosios savybės

Abstrakčiosios klasės taip pat gali apibrėžti abstrakčiąsias savybes, kurios turi būti įgyvendintos išvestinėse klasėse. Tai naudinga norint priversti išvestines klases turėti tam tikrus duomenų elementus.


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()); // Output: https://api.example.com/prod/prod_api_key

const devConfig = new DevelopmentConfiguration();
console.log(devConfig.getFullApiUrl()); // Output: http://localhost:3000/dev/dev_api_key

Šiame pavyzdyje abstrakčioji klasė Configuration apibrėžia dvi abstrakčiąsias savybes: apiKey ir apiUrl. Klasės ProductionConfiguration ir DevelopmentConfiguration praplečia Configuration ir pateikia konkrečias šių savybių reikšmes.

Pažangesni aspektai

Miksinai (Mixins) su abstrakčiosiomis klasėmis

„TypeScript“ leidžia derinti abstrakčiąsias klases su miksinais (mixins), kad būtų sukurti sudėtingesni ir pakartotinai panaudojami komponentai. Miksinai yra būdas kurti klases, sujungiant mažesnes, pakartotinai panaudojamas funkcionalumo dalis.


// Define a type for the constructor of a class
type Constructor = new (...args: any[]) => T;

// Define a mixin function
function Timestamped(Base: TBase) {
 return class extends Base {
 timestamp = new Date();
 };
}

// Another mixin function
function Logged(Base: TBase) {
 return class extends Base {
 log(message: string) {
 console.log(`${this.constructor.name}: ${message}`);
 }
 };
}

abstract class BaseEntity {
 abstract id: number;
}

// Apply the mixins to the BaseEntity abstract class
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); // Output: 123
console.log(user.timestamp); // Output: Current timestamp
user.log("User updated"); // Output: User: User updated

Šis pavyzdys sujungia Timestamped ir Logged miksinus su abstrakčiąja klase BaseEntity, kad sukurtų User klasę, kuri paveldi visų trijų funkcionalumą.

Priklausomybių įterpimas (Dependency Injection)

Abstrakčiąsias klases galima efektyviai naudoti su priklausomybių įterpimu (DI), siekiant atsieti komponentus ir pagerinti testuojamumą. Galite apibrėžti abstrakčiąsias klases kaip savo priklausomybių sąsajas ir tada įterpti konkrečias implementacijas į savo klases.


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 {
 // Implementation to log to a file
 console.log(`[File]: ${message}`);
 }
}

class AppService {
 private logger: Logger;

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

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

// Inject the ConsoleLogger
const consoleLogger = new ConsoleLogger();
const appService1 = new AppService(consoleLogger);
appService1.doSomething();

// Inject the FileLogger
const fileLogger = new FileLogger();
const appService2 = new AppService(fileLogger);
appService2.doSomething();

Šiame pavyzdyje klasė AppService priklauso nuo abstrakčiosios klasės Logger. Konkrečios implementacijos (ConsoleLogger, FileLogger) yra įterpiamos vykdymo metu, leidžiant lengvai perjungti skirtingas registravimo (logging) strategijas.

Geriausios praktikos

Išlaikykite abstrakčiųjų klasių specifiškumą: Kiekviena abstrakčioji klasė turėtų turėti aiškų ir gerai apibrėžtą tikslą.
Venkite perteklinės abstrakcijos: Nekurkite abstrakčiųjų klasių, nebent jos suteikia didelę vertę kodo pakartotinio panaudojamumo ar priverstinės struktūros požiūriu.
Naudokite abstrakčiąsias klases pagrindiniam funkcionalumui: Bendrąją logiką ir algoritmus talpinkite abstrakčiosiose klasėse, o konkrečias implementacijas deleguokite išvestinėms klasėms.
Išsamiai dokumentuokite abstrakčiąsias klases: Aiškiai dokumentuokite abstrakčiosios klasės tikslą ir išvestinių klasių atsakomybes.
Apsvarstykite sąsajų (Interfaces) naudojimą: Jei jums reikia apibrėžti tik kontraktą be jokios implementacijos, apsvarstykite galimybę naudoti sąsajas, o ne abstrakčiąsias klases.

Išvada

„TypeScript“ abstrakčiosios klasės yra galingas įrankis kuriant tvirtas ir lengvai prižiūrimas programas. Suprasdami ir taikydami dalinės implementacijos šablonus, galite pasinaudoti abstrakčiųjų klasių privalumais ir sukurti lankstų, pakartotinai panaudojamą ir gerai struktūrizuotą kodą. Nuo abstrakčių metodų apibrėžimo su numatytosiomis implementacijomis iki abstrakčiųjų klasių naudojimo su miksinais ir priklausomybių įterpimu – galimybės yra didžiulės. Laikydamiesi geriausių praktikų ir atidžiai apsvarstydami savo projektavimo sprendimus, galite efektyviai naudoti abstrakčiąsias klases, kad pagerintumėte savo „TypeScript“ projektų kokybę ir mastelį.

Nesvarbu, ar kuriate didelio masto verslo programą, ar mažą pagalbinių funkcijų biblioteką, „TypeScript“ abstrakčiųjų klasių įvaldymas neabejotinai pagerins jūsų programinės įrangos kūrimo įgūdžius ir leis jums kurti sudėtingesnius bei lengviau prižiūrimus sprendimus.