ടൈപ്പ്സ്ക്രിപ്റ്റ് OOP പാറ്റേണുകൾ: ക്ലാസ് ഡിസൈനിനും ഇൻഹെറിറ്റൻസ് സ്ട്രാറ്റജികൾക്കുമുള്ള ഒരു വഴികാട്ടി

ആധുനിക സോഫ്റ്റ്‌വെയർ വികസനത്തിന്റെ ലോകത്ത്, ശക്തവും, സ്കെയിലബിളും, പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഒരു അടിസ്ഥാന ശിലയായി ടൈപ്പ്സ്ക്രിപ്റ്റ് മാറിയിരിക്കുന്നു. ജാവാസ്ക്രിപ്റ്റിന് മുകളിൽ നിർമ്മിച്ച അതിന്റെ ശക്തമായ ടൈപ്പിംഗ് സിസ്റ്റം, ഡെവലപ്പർമാർക്ക് പിശകുകൾ നേരത്തെ കണ്ടെത്താനും കൂടുതൽ പ്രവചനാത്മകമായ കോഡ് എഴുതാനും സഹായിക്കുന്നു. ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ ശക്തിയുടെ കാതൽ ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് (OOP) തത്വങ്ങൾക്കുള്ള അതിന്റെ സമഗ്രമായ പിന്തുണയാണ്. എന്നിരുന്നാലും, ഒരു ക്ലാസ് എങ്ങനെ നിർമ്മിക്കാമെന്ന് അറിയുന്നത് മാത്രം മതിയാവില്ല. ടൈപ്പ്സ്ക്രിപ്റ്റിൽ വൈദഗ്ദ്ധ്യം നേടുന്നതിന് ക്ലാസ് ഡിസൈൻ, ഇൻഹെറിറ്റൻസ് ശ്രേണികൾ, വിവിധ ആർക്കിടെക്ചറൽ പാറ്റേണുകൾ തമ്മിലുള്ള ഗുണദോഷങ്ങൾ എന്നിവയെക്കുറിച്ച് ആഴത്തിലുള്ള ധാരണ ആവശ്യമാണ്.

ഈ ഗൈഡ് ഒരു ആഗോള പ്രേക്ഷകരായ ഡെവലപ്പർമാർക്കായി രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്, അവരുടെ ഇടത്തരം കഴിവുകൾ ഉറപ്പിക്കുന്നവർ മുതൽ പരിചയസമ്പന്നരായ ആർക്കിടെക്റ്റുകൾ വരെ. നമ്മൾ ടൈപ്പ്സ്ക്രിപ്റ്റിലെ OOP-യുടെ പ്രധാന ആശയങ്ങളിലേക്ക് ആഴത്തിൽ ഇറങ്ങിച്ചെല്ലുകയും, ഫലപ്രദമായ ക്ലാസ് ഡിസൈൻ തന്ത്രങ്ങൾ പര്യവേക്ഷണം ചെയ്യുകയും, കാലങ്ങളായുള്ള ചർച്ചയെ അഭിസംബോധന ചെയ്യുകയും ചെയ്യും: ഇൻഹെറിറ്റൻസ് വേഴ്സസ് കോമ്പോസിഷൻ. ഇത് പൂർത്തിയാകുമ്പോഴേക്കും, വൃത്തിയുള്ളതും, കൂടുതൽ വഴക്കമുള്ളതും, ഭാവിയിൽ സുരക്ഷിതവുമായ കോഡ്ബേസുകളിലേക്ക് നയിക്കുന്ന ഡിസൈൻ തീരുമാനങ്ങൾ എടുക്കാനുള്ള അറിവ് നിങ്ങൾക്ക് ലഭിക്കും.

ടൈപ്പ്സ്ക്രിപ്റ്റിലെ OOP-യുടെ തൂണുകൾ മനസ്സിലാക്കുന്നു

സങ്കീർണ്ണമായ പാറ്റേണുകളിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, ടൈപ്പ്സ്ക്രിപ്റ്റിൽ ബാധകമായ ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗിന്റെ നാല് അടിസ്ഥാന തൂണുകൾ പുനരവലോകനം ചെയ്തുകൊണ്ട് നമുക്ക് ശക്തമായ ഒരടിത്തറ സ്ഥാപിക്കാം.

1. എൻക്യാപ്‌സുലേഷൻ

എൻക്യാപ്‌സുലേഷൻ എന്നത് ഒരു ഒബ്ജക്റ്റിന്റെ ഡാറ്റയും (പ്രോപ്പർട്ടികൾ) ആ ഡാറ്റയിൽ പ്രവർത്തിക്കുന്ന മെത്തേഡുകളും ഒരൊറ്റ യൂണിറ്റിലേക്ക്—ഒരു ക്ലാസ്സിലേക്ക്—ബന്ധിപ്പിക്കുന്ന തത്വമാണ്. ഇത് ഒരു ഒബ്ജക്റ്റിന്റെ ആന്തരിക അവസ്ഥയിലേക്കുള്ള നേരിട്ടുള്ള പ്രവേശനം നിയന്ത്രിക്കുന്നതും ഉൾക്കൊള്ളുന്നു. ടൈപ്പ്സ്ക്രിപ്റ്റ് ഇത് പ്രധാനമായും ആക്‌സസ്സ് മോഡിഫയറുകളിലൂടെയാണ് നേടുന്നത്: public, private, and protected.

ഉദാഹരണം: ഒരു ബാങ്ക് അക്കൗണ്ട്, അതിൽ ബാലൻസ് ഡെപ്പോസിറ്റ്, വിത്ത്ഡ്രോ മെത്തേഡുകളിലൂടെ മാത്രമേ മാറ്റാൻ കഴിയൂ.

            class BankAccount {
  private balance: number = 0;

  constructor(initialBalance: number) {
    if (initialBalance >= 0) {
      this.balance = initialBalance;
    }
  }

  public deposit(amount: number): void {
    if (amount > 0) {
      this.balance += amount;
      console.log(`Deposited: ${amount}. New balance: ${this.balance}`);
    }
  }

  public getBalance(): number {
    // We expose the balance through a method, not directly
    return this.balance;
  }
}
            

              
                Copy
              
            
          

2. അബ്സ്ട്രാക്ഷൻ

സങ്കീർണ്ണമായ നിർവ്വഹണ വിശദാംശങ്ങൾ മറച്ചുവെക്കുകയും ഒരു ഒബ്ജക്റ്റിന്റെ അവശ്യ സവിശേഷതകൾ മാത്രം വെളിപ്പെടുത്തുകയും ചെയ്യുന്നതിനെയാണ് അബ്സ്ട്രാക്ഷൻ എന്ന് പറയുന്നത്. അതിനടിയിലുള്ള സങ്കീർണ്ണമായ യന്ത്രങ്ങളെക്കുറിച്ച് മനസ്സിലാക്കേണ്ട ആവശ്യമില്ലാതെ ഉയർന്ന തലത്തിലുള്ള ആശയങ്ങളുമായി പ്രവർത്തിക്കാൻ ഇത് നമ്മെ അനുവദിക്കുന്നു. ടൈപ്പ്സ്ക്രിപ്റ്റിൽ, abstract ക്ലാസുകളും interfaces-ഉം ഉപയോഗിച്ചാണ് അബ്സ്ട്രാക്ഷൻ പലപ്പോഴും നേടുന്നത്.

ഉദാഹരണം: നിങ്ങൾ ഒരു റിമോട്ട് കൺട്രോൾ ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾ 'പവർ' ബട്ടൺ അമർത്തുകയേ വേണ്ടൂ. ഇൻഫ്രാറെഡ് സിഗ്നലുകളെക്കുറിച്ചോ ആന്തരിക സർക്യൂട്ടിനെക്കുറിച്ചോ നിങ്ങൾ അറിയേണ്ടതില്ല. റിമോട്ട് ടിവിയുടെ പ്രവർത്തനത്തിന് ഒരു അബ്സ്ട്രാക്റ്റ് ഇന്റർഫേസ് നൽകുന്നു.

3. ഇൻഹെറിറ്റൻസ്

ഇൻഹെറിറ്റൻസ് എന്നത് ഒരു പുതിയ ക്ലാസ് (സബ്ക്ലാസ് അല്ലെങ്കിൽ ഡിറൈവ്ഡ് ക്ലാസ്) നിലവിലുള്ള ഒരു ക്ലാസിൽ (സൂപ്പർക്ലാസ് അല്ലെങ്കിൽ ബേസ് ക്ലാസ്) നിന്ന് പ്രോപ്പർട്ടികളും മെത്തേഡുകളും നേടുന്ന ഒരു സംവിധാനമാണ്. ഇത് കോഡ് പുനരുപയോഗം പ്രോത്സാഹിപ്പിക്കുകയും ക്ലാസുകൾക്കിടയിൽ വ്യക്തമായ 'is-a' ബന്ധം സ്ഥാപിക്കുകയും ചെയ്യുന്നു. ടൈപ്പ്സ്ക്രിപ്റ്റ് ഇൻഹെറിറ്റൻസിനായി extends എന്ന കീവേഡ് ഉപയോഗിക്കുന്നു.

ഉദാഹരണം: ഒരു `Manager` എന്നത് `Employee`-യുടെ ഒരു 'is-a' തരം ആണ്. അവർ `name`, `id` പോലുള്ള പൊതുവായ പ്രോപ്പർട്ടികൾ പങ്കിടുന്നു, എന്നാൽ `Manager`-ന് `subordinates` പോലുള്ള അധിക പ്രോപ്പർട്ടികൾ ഉണ്ടാകാം.

            class Employee {
  constructor(public name: string, public id: number) {}

  getProfile(): string {
    return `Name: ${this.name}, ID: ${this.id}`;
  }
}

class Manager extends Employee {
  constructor(name: string, id: number, public subordinates: Employee[]) {
    super(name, id); // Call the parent constructor
  }

  // Managers can also have their own methods
  delegateTask(): void {
    console.log(`${this.name} is delegating tasks.`);
  }
}
            

              
                Copy
              
            
          

4. പോളിമോർഫിസം

പോളിമോർഫിസം, 'പല രൂപങ്ങൾ' എന്നർത്ഥം വരുന്ന, വ്യത്യസ്ത ക്ലാസുകളിലെ ഒബ്ജക്റ്റുകളെ ഒരു പൊതുവായ സൂപ്പർക്ലാസിന്റെ ഒബ്ജക്റ്റുകളായി കണക്കാക്കാൻ അനുവദിക്കുന്നു. ഒരൊറ്റ ഇന്റർഫേസിന് (ഒരു മെത്തേഡ് നാമം പോലെ) വ്യത്യസ്ത അടിസ്ഥാന രൂപങ്ങളെ (നിർവ്വഹണങ്ങൾ) പ്രതിനിധീകരിക്കാൻ ഇത് പ്രാപ്തമാക്കുന്നു. ഇത് പലപ്പോഴും മെത്തേഡ് ഓവർറൈഡിംഗിലൂടെയാണ് നേടുന്നത്.

ഉദാഹരണം: `Circle` ഒബ്ജക്റ്റിനും `Square` ഒബ്ജക്റ്റിനും വ്യത്യസ്തമായി പ്രവർത്തിക്കുന്ന ഒരു `render()` മെത്തേഡ്, രണ്ടും `Shape` ആണെങ്കിലും.

            abstract class Shape {
  abstract draw(): void; // An abstract method must be implemented by subclasses
}

class Circle extends Shape {
  draw(): void {
    console.log("Drawing a circle.");
  }
}

class Square extends Shape {
  draw(): void {
    console.log("Drawing a square.");
  }
}

function renderShapes(shapes: Shape[]): void {
  shapes.forEach(shape => shape.draw()); // Polymorphism in action!
}

const myShapes: Shape[] = [new Circle(), new Square()];
renderShapes(myShapes);
// Output:
// Drawing a circle.
// Drawing a square.
            

              
                Copy
              
            
          

മഹത്തായ സംവാദം: ഇൻഹെറിറ്റൻസും കോമ്പോസിഷനും

OOP-യിലെ ഏറ്റവും നിർണായകമായ ഡിസൈൻ തീരുമാനങ്ങളിൽ ഒന്നാണിത്. ആധുനിക സോഫ്റ്റ്‌വെയർ എഞ്ചിനീയറിംഗിലെ പൊതുവായ ധാരണ "ഇൻഹെറിറ്റൻസിനേക്കാൾ കോമ്പോസിഷന് മുൻഗണന നൽകുക." എന്നതാണ്. രണ്ട് ആശയങ്ങളും ആഴത്തിൽ പര്യവേക്ഷണം ചെയ്തുകൊണ്ട് എന്തുകൊണ്ടെന്ന് നമുക്ക് മനസ്സിലാക്കാം.

എന്താണ് ഇൻഹെറിറ്റൻസ്? 'is-a' ബന്ധം

ഇൻഹെറിറ്റൻസ് ബേസ് ക്ലാസും ഡിറൈവ്ഡ് ക്ലാസും തമ്മിൽ ഒരു ശക്തമായ ബന്ധം സൃഷ്ടിക്കുന്നു. നിങ്ങൾ `extends` ഉപയോഗിക്കുമ്പോൾ, പുതിയ ക്ലാസ് ബേസ് ക്ലാസിന്റെ ഒരു പ്രത്യേക പതിപ്പാണെന്ന് നിങ്ങൾ പ്രസ്താവിക്കുകയാണ്. വ്യക്തമായ ഒരു ശ്രേണി ബന്ധം നിലനിൽക്കുമ്പോൾ കോഡ് പുനരുപയോഗിക്കുന്നതിനുള്ള ശക്തമായ ഒരു ഉപകരണമാണിത്.

• ഗുണങ്ങൾ:
  • കോഡ് പുനരുപയോഗം: പൊതുവായ ലോജിക് ബേസ് ക്ലാസിൽ ഒരിക്കൽ നിർവചിക്കപ്പെടുന്നു.
  • പോളിമോർഫിസം: നമ്മുടെ `Shape` ഉദാഹരണത്തിൽ കണ്ടതുപോലെ, ഗംഭീരമായ പോളിമോർഫിക് സ്വഭാവം അനുവദിക്കുന്നു.
  • വ്യക്തമായ ശ്രേണി: ഇത് ഒരു യഥാർത്ഥ ലോക, ടോപ്പ്-ഡൗൺ വർഗ്ഗീകരണ സംവിധാനത്തെ മാതൃകയാക്കുന്നു.
• ദോഷങ്ങൾ:
  • ശക്തമായ ബന്ധം: ബേസ് ക്ലാസിലെ മാറ്റങ്ങൾ ഡിറൈവ്ഡ് ക്ലാസുകളെ അവിചാരിതമായി തകർക്കും. ഇത് "fragile base class problem" എന്നറിയപ്പെടുന്നു.
  • ശ്രേണിയുടെ നരകം: അമിതമായ ഉപയോഗം മനസ്സിലാക്കാനും പരിപാലിക്കാനും ബുദ്ധിമുട്ടുള്ള ആഴമേറിയതും സങ്കീർണ്ണവും വഴക്കമില്ലാത്തതുമായ ഇൻഹെറിറ്റൻസ് ശൃംഖലകളിലേക്ക് നയിച്ചേക്കാം.
  • വഴക്കമില്ലായ്മ: ടൈപ്പ്സ്ക്രിപ്റ്റിൽ ഒരു ക്ലാസിന് ഒരു ക്ലാസിൽ നിന്ന് മാത്രമേ ഇൻഹെറിറ്റ് ചെയ്യാൻ കഴിയൂ (സിംഗിൾ ഇൻഹെറിറ്റൻസ്), ഇത് പരിമിതപ്പെടുത്താം. നിങ്ങൾക്ക് ബന്ധമില്ലാത്ത ഒന്നിലധികം ക്ലാസുകളിൽ നിന്ന് ഫീച്ചറുകൾ ഇൻഹെറിറ്റ് ചെയ്യാൻ കഴിയില്ല.

ഇൻഹെറിറ്റൻസ് എപ്പോഴാണ് ഒരു നല്ല തിരഞ്ഞെടുപ്പ്?

ബന്ധം യഥാർത്ഥത്തിൽ 'is-a' ആയിരിക്കുകയും അത് സ്ഥിരതയുള്ളതും മാറാൻ സാധ്യതയില്ലാത്തതുമാകുമ്പോൾ ഇൻഹെറിറ്റൻസ് ഉപയോഗിക്കുക. ഉദാഹരണത്തിന്, `CheckingAccount`, `SavingsAccount` എന്നിവ രണ്ടും അടിസ്ഥാനപരമായി `BankAccount`-ന്റെ തരങ്ങളാണ്. ഈ ശ്രേണി അർത്ഥവത്തായതും പുനർനിർമ്മിക്കാൻ സാധ്യതയില്ലാത്തതുമാണ്.

എന്താണ് കോമ്പോസിഷൻ? 'has-a' ബന്ധം

ചെറുതും സ്വതന്ത്രവുമായ ഒബ്ജക്റ്റുകളിൽ നിന്ന് സങ്കീർണ്ണമായ ഒബ്ജക്റ്റുകൾ നിർമ്മിക്കുന്നത് കോമ്പോസിഷനിൽ ഉൾപ്പെടുന്നു. ഒരു ക്ലാസ് മറ്റൊന്നായിരിക്കുന്നതിനു പകരം, ആവശ്യമായ പ്രവർത്തനക്ഷമത നൽകുന്ന മറ്റ് ഒബ്ജക്റ്റുകൾ അതിന് ഉണ്ട്. ഇത് ഒരു അയഞ്ഞ ബന്ധം സൃഷ്ടിക്കുന്നു, കാരണം ക്ലാസ് സംയോജിപ്പിച്ച ഒബ്ജക്റ്റുകളുടെ പബ്ലിക് ഇന്റർഫേസുമായി മാത്രമേ സംവദിക്കുന്നുള്ളൂ.

• ഗുണങ്ങൾ:
  • വഴക്കം: സംയോജിപ്പിച്ച ഒബ്ജക്റ്റുകൾ മാറ്റിസ്ഥാപിച്ച് റൺടൈമിൽ പ്രവർത്തനക്ഷമത മാറ്റാൻ കഴിയും.
  • അയഞ്ഞ ബന്ധം: കണ്ടെയ്നിംഗ് ക്ലാസിന് അത് ഉപയോഗിക്കുന്ന ഘടകങ്ങളുടെ ആന്തരിക പ്രവർത്തനങ്ങൾ അറിയേണ്ടതില്ല. ഇത് കോഡ് ടെസ്റ്റ് ചെയ്യാനും പരിപാലിക്കാനും എളുപ്പമാക്കുന്നു.
  • ശ്രേണി പ്രശ്നങ്ങൾ ഒഴിവാക്കുന്നു: സങ്കീർണ്ണമായ ഇൻഹെറിറ്റൻസ് ട്രീ സൃഷ്ടിക്കാതെ തന്നെ നിങ്ങൾക്ക് വിവിധ ഉറവിടങ്ങളിൽ നിന്നുള്ള പ്രവർത്തനങ്ങൾ സംയോജിപ്പിക്കാൻ കഴിയും.
  • വ്യക്തമായ ഉത്തരവാദിത്തങ്ങൾ: ഓരോ ഘടക ക്ലാസിനും സിംഗിൾ റെസ്പോൺസിബിലിറ്റി പ്രിൻസിപ്പിൾ പാലിക്കാൻ കഴിയും.
• ദോഷങ്ങൾ:
  • കൂടുതൽ ബോയിലർപ്ലേറ്റ്: ലളിതമായ ഇൻഹെറിറ്റൻസ് മോഡലുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ വ്യത്യസ്ത ഘടകങ്ങളെ ബന്ധിപ്പിക്കുന്നതിന് ഇതിന് ചിലപ്പോൾ കൂടുതൽ കോഡ് ആവശ്യമായി വന്നേക്കാം.
  • ശ്രേണികൾക്ക് അത്ര അവബോധജന്യമല്ല: ഇത് ഇൻഹെറിറ്റൻസ് ചെയ്യുന്നതുപോലെ സ്വാഭാവിക വർഗ്ഗീകരണങ്ങളെ നേരിട്ട് മാതൃകയാക്കുന്നില്ല.

ഒരു പ്രായോഗിക ഉദാഹരണം: കാർ

ഒരു `Car` കോമ്പോസിഷന്റെ ഒരു മികച്ച ഉദാഹരണമാണ്. ഒരു `Car` എന്നത് `Engine`-ന്റെ ഒരു തരം അല്ല, `Wheel`-ന്റെ ഒരു തരവുമല്ല. പകരം, ഒരു `Car`-ന് ഒരു `Engine` ഉണ്ട്, `Wheels`-ഉം ഉണ്ട്.

            // Component classes
class Engine {
  start() {
    console.log("Engine starting...");
  }
}

class GPS {
  navigate(destination: string) {
    console.log(`Navigating to ${destination}...`);
  }
}

// The composite class
class Car {
  private readonly engine: Engine;
  private readonly gps: GPS;

  constructor() {
    // The Car creates its own parts
    this.engine = new Engine();
    this.gps = new GPS();
  }

  driveTo(destination: string) {
    this.engine.start();
    this.gps.navigate(destination);
    console.log("Car is on its way.");
  }
}

const myCar = new Car();
myCar.driveTo("New York City");
            

              
                Copy
              
            
          

ഈ ഡിസൈൻ വളരെ വഴക്കമുള്ളതാണ്. നമുക്ക് ഒരു `ElectricEngine` ഉള്ള ഒരു `Car` നിർമ്മിക്കണമെങ്കിൽ, നമുക്ക് ഒരു പുതിയ ഇൻഹെറിറ്റൻസ് ശൃംഖല ആവശ്യമില്ല. ഡിപ്പൻഡൻസി ഇഞ്ചക്ഷൻ ഉപയോഗിച്ച് `Car`-ന് അതിന്റെ ഘടകങ്ങൾ നൽകാൻ നമുക്ക് കഴിയും, ഇത് അതിനെ കൂടുതൽ മോഡുലാർ ആക്കുന്നു.

            interface IEngine {
  start(): void;
}

class PetrolEngine implements IEngine {
  start() { console.log("Petrol engine starting..."); }
}

class ElectricEngine implements IEngine {
  start() { console.log("Silent electric engine starting..."); }
}

class AdvancedCar {
  // The car depends on an abstraction (interface), not a concrete class
  constructor(private engine: IEngine) {}

  startJourney() {
    this.engine.start();
    console.log("Journey has begun.");
  }
}

const tesla = new AdvancedCar(new ElectricEngine());
tesla.startJourney();

const ford = new AdvancedCar(new PetrolEngine());
ford.startJourney();
            

              
                Copy
              
            
          

ടൈപ്പ്സ്ക്രിപ്റ്റിലെ നൂതന തന്ത്രങ്ങളും പാറ്റേണുകളും

ഇൻഹെറിറ്റൻസും കോമ്പോസിഷനും തമ്മിലുള്ള അടിസ്ഥാന തിരഞ്ഞെടുപ്പിനപ്പുറം, സങ്കീർണ്ണവും വഴക്കമുള്ളതുമായ ക്ലാസ് ഡിസൈനുകൾ സൃഷ്ടിക്കുന്നതിന് ടൈപ്പ്സ്ക്രിപ്റ്റ് ശക്തമായ ഉപകരണങ്ങൾ നൽകുന്നു.

1. അബ്സ്ട്രാക്റ്റ് ക്ലാസുകൾ: ഇൻഹെറിറ്റൻസിന്റെ ബ്ലൂപ്രിന്റ്

നിങ്ങൾക്ക് ശക്തമായ 'is-a' ബന്ധം ഉള്ളപ്പോൾ, എന്നാൽ ബേസ് ക്ലാസുകൾ സ്വന്തമായി ഇൻസ്റ്റാന്റേറ്റ് ചെയ്യാൻ കഴിയില്ലെന്ന് ഉറപ്പാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ, `abstract` ക്ലാസുകൾ ഉപയോഗിക്കുക. അവ ഒരു ബ്ലൂപ്രിന്റായി പ്രവർത്തിക്കുന്നു, പൊതുവായ മെത്തേഡുകളും പ്രോപ്പർട്ടികളും നിർവചിക്കുന്നു, കൂടാതെ ഡിറൈവ്ഡ് ക്ലാസുകൾ നിർബന്ധമായും നടപ്പിലാക്കേണ്ട `abstract` മെത്തേഡുകൾ പ്രഖ്യാപിക്കാനും കഴിയും.

ഉപയോഗ സാഹചര്യം: ഒരു പേയ്‌മെന്റ് പ്രോസസ്സിംഗ് സിസ്റ്റം. എല്ലാ ഗേറ്റ്‌വേകൾക്കും `pay()`, `refund()` മെത്തേഡുകൾ ഉണ്ടായിരിക്കണമെന്ന് നിങ്ങൾക്കറിയാം, എന്നാൽ ഓരോ ദാതാവിനും (ഉദാ. Stripe, PayPal) നിർവ്വഹണം പ്രത്യേകമാണ്.

            abstract class PaymentGateway {
  constructor(public apiKey: string) {}

  // A concrete method shared by all subclasses
  protected connect(): void {
    console.log("Connecting to payment service...");
  }

  // Abstract methods that subclasses must implement
  abstract processPayment(amount: number): boolean;
  abstract issueRefund(transactionId: string): boolean;
}

class StripeGateway extends PaymentGateway {
  processPayment(amount: number): boolean {
    this.connect();
    console.log(`Processing ${amount} via Stripe.`);
    return true;
  }

  issueRefund(transactionId: string): boolean {
    console.log(`Refunding transaction ${transactionId} via Stripe.`);
    return true;
  }
}

// const gateway = new PaymentGateway("key"); // Error: Cannot create an instance of an abstract class.
const stripe = new StripeGateway("sk_test_123");
stripe.processPayment(100);
            

              
                Copy
              
            
          

2. ഇന്റർഫേസുകൾ: സ്വഭാവത്തിനുള്ള കരാറുകൾ നിർവചിക്കൽ

ടൈപ്പ്സ്ക്രിപ്റ്റിലെ ഇന്റർഫേസുകൾ ഒരു ക്ലാസ്സിന്റെ രൂപത്തിന് ഒരു കരാർ നിർവചിക്കാനുള്ള ഒരു മാർഗമാണ്. ഒരു ക്ലാസ്സിനുണ്ടായിരിക്കേണ്ട പ്രോപ്പർട്ടികളും മെത്തേഡുകളും അവ വ്യക്തമാക്കുന്നു, പക്ഷേ അവ ഒരു നിർവ്വഹണവും നൽകുന്നില്ല. ഒരു ക്ലാസിന് ഒന്നിലധികം ഇന്റർഫേസുകൾ `implement` ചെയ്യാൻ കഴിയും, ഇത് അവയെ കോമ്പോസിഷണൽ, ഡീകപ്പിൾഡ് ഡിസൈനിന്റെ ഒരു മൂലക്കല്ലാക്കി മാറ്റുന്നു.

ഇന്റർഫേസ് vs. അബ്സ്ട്രാക്റ്റ് ക്ലാസ്

• നിരവധി അടുത്ത ബന്ധമുള്ള ക്ലാസുകൾക്കിടയിൽ നടപ്പിലാക്കിയ കോഡ് പങ്കിടാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഒരു അബ്സ്ട്രാക്റ്റ് ക്ലാസ് ഉപയോഗിക്കുക.
• പൊരുത്തമില്ലാത്ത, ബന്ധമില്ലാത്ത ക്ലാസുകൾക്ക് നടപ്പിലാക്കാൻ കഴിയുന്ന ഒരു സ്വഭാവത്തിനുള്ള കരാർ നിർവചിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഒരു ഇന്റർഫേസ് ഉപയോഗിക്കുക.

ഉപയോഗ സാഹചര്യം: ഒരു സിസ്റ്റത്തിൽ, നിരവധി വ്യത്യസ്ത ഒബ്ജക്റ്റുകൾ ഒരു സ്ട്രിംഗ് ഫോർമാറ്റിലേക്ക് സീരിയലൈസ് ചെയ്യേണ്ടതായി വന്നേക്കാം (ഉദാഹരണത്തിന്, ലോഗിംഗ് അല്ലെങ്കിൽ സ്റ്റോറേജിനായി). ഈ ഒബ്ജക്റ്റുകൾ (`User`, `Product`, `Order`) ബന്ധമില്ലാത്തവയാണ്, പക്ഷേ ഒരു പൊതുവായ കഴിവ് പങ്കിടുന്നു.

            interface ISerializable {
  serialize(): string;
}

class User implements ISerializable {
  constructor(public id: number, public name: string) {}

  serialize(): string {
    return JSON.stringify({ id: this.id, name: this.name });
  }
}

class Product implements ISerializable {
  constructor(public sku: string, public price: number) {}

  serialize(): string {
    return JSON.stringify({ sku: this.sku, price: this.price });
  }
}

function logItems(items: ISerializable[]): void {
  items.forEach(item => {
    console.log("Serialized item:", item.serialize());
  });
}

const user = new User(1, "Alice");
const product = new Product("TSHIRT-RED", 19.99);
logItems([user, product]);
            

              
                Copy
              
            
          

3. മിക്സിനുകൾ: കോഡ് പുനരുപയോഗത്തിനുള്ള ഒരു കോമ്പോസിഷണൽ സമീപനം

ടൈപ്പ്സ്ക്രിപ്റ്റ് സിംഗിൾ ഇൻഹെറിറ്റൻസ് മാത്രമേ അനുവദിക്കുന്നുള്ളൂ എന്നതിനാൽ, നിങ്ങൾക്ക് ഒന്നിലധികം ഉറവിടങ്ങളിൽ നിന്ന് കോഡ് പുനരുപയോഗിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ എന്തുചെയ്യും? ഇവിടെയാണ് മിക്സിൻ പാറ്റേൺ വരുന്നത്. മിക്സിനുകൾ ഒരു കൺസ്ട്രക്റ്റർ എടുക്കുകയും പുതിയ പ്രവർത്തനക്ഷമതയോടെ അതിനെ വികസിപ്പിക്കുന്ന ഒരു പുതിയ കൺസ്ട്രക്റ്റർ തിരികെ നൽകുകയും ചെയ്യുന്ന ഫംഗ്ഷനുകളാണ്. ഒരു ക്ലാസിലേക്ക് കഴിവുകൾ "മിക്സ് ഇൻ" ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു തരം കോമ്പോസിഷനാണിത്.

ഉപയോഗ സാഹചര്യം: നിങ്ങൾക്ക് ഒന്നിലധികം മോഡൽ ക്ലാസുകളിലേക്ക് `Timestamp` (`createdAt`, `updatedAt` സഹിതം), `SoftDeletable` (`deletedAt` പ്രോപ്പർട്ടിയും `softDelete()` മെത്തേഡും സഹിതം) സ്വഭാവങ്ങൾ ചേർക്കാൻ താൽപ്പര്യമുണ്ട്.

            // A Type helper for mixins
type Constructor<T = {}> = new (...args: any[]) => T;

// Timestamp Mixin
function Timestamped<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    createdAt: Date = new Date();
    updatedAt: Date = new Date();
  };
}

// SoftDeletable Mixin
function SoftDeletable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    deletedAt: Date | null = null;

    softDelete() {
      this.deletedAt = new Date();
      console.log("Item has been soft deleted.");
    }
  };
}

// Base class
class DocumentModel {
  constructor(public title: string) {}
}

// Create a new class by composing mixins
const UserAccountModel = SoftDeletable(Timestamped(DocumentModel));

const userAccount = new UserAccountModel("My User Account");
console.log(userAccount.title);
console.log(userAccount.createdAt);
userAccount.softDelete();
console.log(userAccount.deletedAt);
            

              
                Copy
              
            
          

ഉപസംഹാരം: ഭാവിയിൽ സുരക്ഷിതമായ ടൈപ്പ്സ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കൽ

ടൈപ്പ്സ്ക്രിപ്റ്റിൽ ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗിൽ വൈദഗ്ദ്ധ്യം നേടുന്നത് സിന്റാക്സ് മനസ്സിലാക്കുന്നതിൽ നിന്ന് ഡിസൈൻ ഫിലോസഫി സ്വീകരിക്കുന്നതിലേക്കുള്ള ഒരു യാത്രയാണ്. ക്ലാസ് ഘടന, ഇൻഹെറിറ്റൻസ്, കോമ്പോസിഷൻ എന്നിവ സംബന്ധിച്ച് നിങ്ങൾ എടുക്കുന്ന തീരുമാനങ്ങൾ നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ദീർഘകാല ആരോഗ്യത്തിൽ കാര്യമായ സ്വാധീനം ചെലുത്തുന്നു.

നിങ്ങളുടെ ആഗോള ഡെവലപ്‌മെന്റ് പരിശീലനത്തിനായുള്ള പ്രധാന കാര്യങ്ങൾ ഇതാ:

1. തൂണുകളിൽ നിന്ന് ആരംഭിക്കുക: എൻക്യാപ്‌സുലേഷൻ, അബ്സ്ട്രാക്ഷൻ, ഇൻഹെറിറ്റൻസ്, പോളിമോർഫിസം എന്നിവയെക്കുറിച്ച് നിങ്ങൾക്ക് വ്യക്തമായ ധാരണയുണ്ടെന്ന് ഉറപ്പാക്കുക. അവ OOP-യുടെ പദാവലിയാണ്.
2. ഇൻഹെറിറ്റൻസിനേക്കാൾ കോമ്പോസിഷന് മുൻഗണന നൽകുക: ഈ തത്വം നിങ്ങളെ കൂടുതൽ വഴക്കമുള്ളതും മോഡുലാർ ആയതും ടെസ്റ്റ് ചെയ്യാൻ എളുപ്പമുള്ളതുമായ കോഡിലേക്ക് നയിക്കും. കോമ്പോസിഷനിൽ നിന്ന് ആരംഭിച്ച്, വ്യക്തവും സ്ഥിരതയുള്ളതുമായ "is-a" ബന്ധം നിലനിൽക്കുമ്പോൾ മാത്രം ഇൻഹെറിറ്റൻസിലേക്ക് പോകുക.
3. ജോലിക്ക് അനുയോജ്യമായ ഉപകരണം ഉപയോഗിക്കുക:
   • യഥാർത്ഥ സ്പെഷ്യലൈസേഷനും സ്ഥിരമായ ഒരു ശ്രേണിയിൽ കോഡ് പങ്കിടലിനും ഇൻഹെറിറ്റൻസ് ഉപയോഗിക്കുക.
   • ഒരു കൂട്ടം ക്ലാസുകൾക്ക് ഒരു പൊതുവായ അടിസ്ഥാനം നിർവചിക്കാനും, ചില നിർവ്വഹണങ്ങൾ പങ്കിടുമ്പോൾ തന്നെ ഒരു കരാർ നടപ്പിലാക്കാനും അബ്സ്ട്രാക്റ്റ് ക്ലാസുകൾ ഉപയോഗിക്കുക.
   • ഏത് ക്ലാസിനും നടപ്പിലാക്കാൻ കഴിയുന്ന സ്വഭാവത്തിനുള്ള കരാറുകൾ നിർവചിക്കാൻ ഇന്റർഫേസുകൾ ഉപയോഗിക്കുക, ഇത് ശക്തമായ ഡീകപ്ലിംഗ് പ്രോത്സാഹിപ്പിക്കുന്നു.
   • സിംഗിൾ ഇൻഹെറിറ്റൻസിന്റെ പരിമിതികൾ മറികടന്ന്, ഒന്നിലധികം ഉറവിടങ്ങളിൽ നിന്ന് ഒരു ക്ലാസിലേക്ക് പ്രവർത്തനങ്ങൾ സംയോജിപ്പിക്കേണ്ടിവരുമ്പോൾ മിക്സിനുകൾ ഉപയോഗിക്കുക.

ഈ പാറ്റേണുകളെക്കുറിച്ച് വിമർശനാത്മകമായി ചിന്തിക്കുകയും അവയുടെ ഗുണദോഷങ്ങൾ മനസ്സിലാക്കുകയും ചെയ്യുന്നതിലൂടെ, നിങ്ങൾക്ക് ഇന്ന് ശക്തവും കാര്യക്ഷമവുമായ ടൈപ്പ്സ്ക്രിപ്റ്റ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ കഴിയും, മാത്രമല്ല, വർഷങ്ങളോളം പൊരുത്തപ്പെടുത്താനും വികസിപ്പിക്കാനും പരിപാലിക്കാനും എളുപ്പമുള്ളവയും - നിങ്ങളോ നിങ്ങളുടെ ടീമോ ലോകത്ത് എവിടെയായിരുന്നാലും.