TypeScript OOP પૅટર્ન્સ: વર્ગ ડિઝાઇન અને વારસા વ્યૂહરચનાઓ માટે માર્ગદર્શિકા

આધુનિક સૉફ્ટવેર ડેવલપમેન્ટની દુનિયામાં, TypeScript મજબૂત, સ્કેલેબલ અને જાળવી શકાય તેવી એપ્લિકેશનો બનાવવા માટે એક આધારસ્તંભ તરીકે ઉભરી આવ્યું છે. જાવાસ્ક્રિપ્ટ પર બનેલી તેની મજબૂત ટાઇપિંગ સિસ્ટમ, વિકાસકર્તાઓને વહેલી તકે ભૂલો પકડવા અને વધુ અનુમાનિત કોડ લખવા માટેનાં સાધનો પૂરાં પાડે છે. TypeScriptની શક્તિના કેન્દ્રમાં ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગ (OOP) સિદ્ધાંતો માટે તેનો વ્યાપક સપોર્ટ રહેલો છે. જો કે, માત્ર વર્ગ કેવી રીતે બનાવવો તે જાણવું પૂરતું નથી. TypeScriptમાં નિપુણતા મેળવવા માટે વર્ગ ડિઝાઇન, વારસો વંશવેલો અને વિવિધ આર્કિટેક્ચરલ પૅટર્ન્સ વચ્ચેના ટ્રેડ-ઑફ્સની ઊંડી સમજ જરૂરી છે.

આ માર્ગદર્શિકા મધ્યવર્તી કુશળતાને મજબૂત કરનારાઓથી લઈને અનુભવી આર્કિટેક્ટ્સ સુધીના વિકાસકર્તાઓના વૈશ્વિક પ્રેક્ષકો માટે બનાવવામાં આવી છે. અમે TypeScriptમાં OOPના મુખ્ય ખ્યાલોમાં ઊંડા ઊતરીશું, અસરકારક વર્ગ ડિઝાઇન વ્યૂહરચનાઓનું અન્વેષણ કરીશું અને યુગ-જૂની ચર્ચાનો સામનો કરીશું: વારસો વિરુદ્ધ કમ્પોઝિશન. અંત સુધીમાં, તમે માહિતગાર ડિઝાઇન નિર્ણયો લેવા માટે જ્ઞાનથી સજ્જ થશો જે સ્વચ્છ, વધુ લવચીક અને ભવિષ્યને સુરક્ષિત કોડબેઝ તરફ દોરી જશે.

TypeScriptમાં OOPના સ્તંભોને સમજવું

જટિલ પૅટર્ન્સમાં ઊંડાણપૂર્વક તપાસ કરતા પહેલાં, ચાલો TypeScriptને લાગુ પડે તે રીતે ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગના ચાર મૂળભૂત સ્તંભોની ફરી મુલાકાત લઈને એક મજબૂત પાયો સ્થાપિત કરીએ.

1. એન્કેપ્સ્યુલેશન

એન્કેપ્સ્યુલેશન એ ઑબ્જેક્ટના ડેટા (ગુણધર્મો) અને તે ડેટા પર કાર્ય કરતી પદ્ધતિઓને એક જ એકમ—એક વર્ગમાં બંડલ કરવાનો સિદ્ધાંત છે. તેમાં ઑબ્જેક્ટની આંતરિક સ્થિતિમાં સીધી ઍક્સેસને પ્રતિબંધિત કરવાનો પણ સમાવેશ થાય છે. TypeScript આ મુખ્યત્વે ઍક્સેસ મોડિફાયર દ્વારા પ્રાપ્ત કરે છે: public, private અને 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. એબ્સ્ટ્રેક્શન

એબ્સ્ટ્રેક્શન એટલે જટિલ અમલીકરણ વિગતોને છુપાવવી અને ઑબ્જેક્ટની આવશ્યક સુવિધાઓ જ જાહેર કરવી. તે અમને નીચેની જટિલ મશીનરીને સમજવાની જરૂર વગર ઉચ્ચ-સ્તરના ખ્યાલો સાથે કામ કરવાની મંજૂરી આપે છે. TypeScriptમાં, એબ્સ્ટ્રેક્શન ઘણીવાર abstract વર્ગો અને interfacesનો ઉપયોગ કરીને પ્રાપ્ત થાય છે.

ઉદાહરણ: જ્યારે તમે રિમોટ કંટ્રોલનો ઉપયોગ કરો છો, ત્યારે તમે ફક્ત "પાવર" બટન દબાવો છો. તમારે ઇન્ફ્રારેડ સિગ્નલો અથવા આંતરિક સર્કિટરી વિશે જાણવાની જરૂર નથી. રિમોટ ટીવીની કાર્યક્ષમતા માટે એક અમૂર્ત ઇન્ટરફેસ પ્રદાન કરે છે.

3. વારસો

વારસો એ એક એવી પદ્ધતિ છે જ્યાં એક નવો વર્ગ (સબક્લાસ અથવા ડેરીવ્ડ ક્લાસ) હાલના વર્ગ (સુપરક્લાસ અથવા બેઝ ક્લાસ) પાસેથી ગુણધર્મો અને પદ્ધતિઓ વારસામાં મેળવે છે. તે કોડ પુનઃઉપયોગને પ્રોત્સાહન આપે છે અને વર્ગો વચ્ચે સ્પષ્ટ "ઇઝ-એ" સંબંધ સ્થાપિત કરે છે. TypeScript વારસા માટે extends કીવર્ડનો ઉપયોગ કરે છે.

ઉદાહરણ: એક `Manager` `Employee`નો "ઇઝ-એ" પ્રકાર છે. તેઓ `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માં આ એક સૌથી નિર્ણાયક ડિઝાઇન નિર્ણયો પૈકીનો એક છે. આધુનિક સૉફ્ટવેર એન્જિનિયરિંગમાં સામાન્ય શાણપણ એ છે કે "વારસા પર કમ્પોઝિશનની તરફેણ કરો." ચાલો બંને ખ્યાલોને ઊંડાણપૂર્વક અન્વેષણ કરીને સમજીએ કે શા માટે.

વારસો શું છે? "ઇઝ-એ" સંબંધ

વારસો બેઝ ક્લાસ અને ડેરીવ્ડ ક્લાસ વચ્ચે ચુસ્ત જોડાણ બનાવે છે. જ્યારે તમે `extends`નો ઉપયોગ કરો છો, ત્યારે તમે જણાવી રહ્યા છો કે નવો વર્ગ બેઝ ક્લાસનું વિશિષ્ટ સંસ્કરણ છે. જ્યારે સ્પષ્ટ વંશવેલો સંબંધ અસ્તિત્વમાં હોય ત્યારે તે કોડ પુનઃઉપયોગ માટે એક શક્તિશાળી સાધન છે.

• ગુણ:
  • કોડ પુનઃઉપયોગ: સામાન્ય તર્ક બેઝ ક્લાસમાં એકવાર વ્યાખ્યાયિત કરવામાં આવે છે.
  • પોલિમોરફિઝમ: અમારા `Shape` ઉદાહરણમાં જોવા મળ્યા મુજબ ભવ્ય, પોલિમોરફિક વર્તનની મંજૂરી આપે છે.
  • સ્પષ્ટ વંશવેલો: તે વાસ્તવિક દુનિયાની ટોપ-ડાઉન વર્ગીકરણ સિસ્ટમનું મોડેલ બનાવે છે.
• વિપક્ષ:
  • ચુસ્ત જોડાણ: બેઝ ક્લાસમાં ફેરફારો અજાણતાં ડેરીવ્ડ ક્લાસને તોડી શકે છે. આને "નાજુક બેઝ ક્લાસ સમસ્યા" તરીકે ઓળખવામાં આવે છે.
  • વંશવેલો નરક: વધુ પડતો ઉપયોગ ઊંડી, જટિલ અને કઠોર વારસાગત સાંકળો તરફ દોરી શકે છે જેને સમજવી અને જાળવવી મુશ્કેલ છે.
  • અલવચીક: TypeScriptમાં એક વર્ગ ફક્ત અન્ય એક વર્ગ (સિંગલ વારસો) પાસેથી જ વારસામાં મેળવી શકે છે, જે મર્યાદિત હોઈ શકે છે. તમે બહુવિધ, અસંબંધિત વર્ગોમાંથી સુવિધાઓ વારસામાં મેળવી શકતા નથી.

વારસો ક્યારે સારો વિકલ્પ છે?

જ્યારે સંબંધ ખરેખર "ઇઝ-એ" હોય અને તે સ્થિર હોય અને બદલાય તેવી શક્યતા ન હોય ત્યારે વારસાનો ઉપયોગ કરો. ઉદાહરણ તરીકે, `CheckingAccount` અને `SavingsAccount` બંને મૂળભૂત રીતે `BankAccount`ના પ્રકારો છે. આ વંશવેલો અર્થપૂર્ણ છે અને તેને ફરીથી મોડેલ બનાવવાની શક્યતા નથી.

કમ્પોઝિશન શું છે? "હેઝ-એ" સંબંધ

કમ્પોઝિશનમાં નાના, સ્વતંત્ર ઑબ્જેક્ટ્સમાંથી જટિલ ઑબ્જેક્ટ્સનું નિર્માણ શામેલ છે. વર્ગ બીજું કંઈક હોવાને બદલે, તેની પાસે અન્ય ઑબ્જેક્ટ્સ છે જે જરૂરી કાર્યક્ષમતા પ્રદાન કરે છે. આ એક છૂટક જોડાણ બનાવે છે, કારણ કે વર્ગ ફક્ત કમ્પોઝ્ડ ઑબ્જેક્ટ્સના જાહેર ઇન્ટરફેસ સાથે જ સંપર્ક કરે છે.

• ગુણ:
  • લવચીકતા: કમ્પોઝ્ડ ઑબ્જેક્ટ્સને બદલીને રનટાઇમ પર કાર્યક્ષમતા બદલી શકાય છે.
  • છૂટક જોડાણ: સમાવિષ્ટ વર્ગને તે ઉપયોગ કરે છે તે ઘટકોની આંતરિક કામગીરી જાણવાની જરૂર નથી. આ કોડને પરીક્ષણ અને જાળવણી કરવાનું સરળ બનાવે છે.
  • વંશવેલો સમસ્યાઓથી બચે છે: તમે ગૂંચવાયેલા વારસાના વૃક્ષને બનાવ્યા વિના વિવિધ સ્ત્રોતોમાંથી કાર્યક્ષમતાઓને જોડી શકો છો.
  • સ્પષ્ટ જવાબદારીઓ: દરેક ઘટક વર્ગ સિંગલ જવાબદારી સિદ્ધાંતનું પાલન કરી શકે છે.
• વિપક્ષ:
  • વધુ બોઇલરપ્લેટ: કેટલીકવાર સરળ વારસા મોડેલની સરખામણીમાં વિવિધ ઘટકોને વાયર અપ કરવા માટે વધુ કોડની જરૂર પડી શકે છે.
  • વંશવેલો માટે ઓછું સાહજિક: તે કુદરતી વર્ગીકરણને વારસાની જેમ સીધી રીતે મોડેલ કરતું નથી.

એક વ્યવહારુ ઉદાહરણ: કાર

એક `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
              
            
          

TypeScriptમાં અદ્યતન વ્યૂહરચનાઓ અને પૅટર્ન્સ

વારસા અને કમ્પોઝિશન વચ્ચેની મૂળભૂત પસંદગીથી આગળ, TypeScript અત્યાધુનિક અને લવચીક વર્ગ ડિઝાઇન બનાવવા માટે શક્તિશાળી સાધનો પ્રદાન કરે છે.

1. એબ્સ્ટ્રેક્ટ વર્ગો: વારસા માટે બ્લુપ્રિન્ટ

જ્યારે તમારી પાસે મજબૂત "ઇઝ-એ" સંબંધ હોય પરંતુ તમે એ સુનિશ્ચિત કરવા માંગતા હો કે બેઝ વર્ગો તેમના પોતાના પર ઇન્સ્ટન્ટિએટ થઈ શકતા નથી, ત્યારે `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. ઇન્ટરફેસો: વર્તન માટે કરારો વ્યાખ્યાયિત કરવા

TypeScriptમાં ઇન્ટરફેસો એ વર્ગના આકાર માટે કરારને વ્યાખ્યાયિત કરવાનો એક માર્ગ છે. તેઓ સ્પષ્ટ કરે છે કે વર્ગમાં કયા ગુણધર્મો અને પદ્ધતિઓ હોવી આવશ્યક છે, પરંતુ તેઓ કોઈ અમલીકરણ પ્રદાન કરતા નથી. એક વર્ગ બહુવિધ ઇન્ટરફેસોને `implement` કરી શકે છે, જે તેમને કમ્પોઝિશનલ અને ડીકપલ્ડ ડિઝાઇનનો આધારસ્તંભ બનાવે છે.

ઇન્ટરફેસ વિરુદ્ધ એબ્સ્ટ્રેક્ટ વર્ગ

• જ્યારે તમે નજીકથી સંબંધિત કેટલાક વર્ગોમાં અમલમાં મૂકાયેલ કોડ શેર કરવા માંગતા હોવ ત્યારે abstract classનો ઉપયોગ કરો.
• જ્યારે તમે વર્તન માટે કરાર વ્યાખ્યાયિત કરવા માંગતા હોવ ત્યારે interfaceનો ઉપયોગ કરો જે વિભિન્ન, અસંબંધિત વર્ગો દ્વારા અમલમાં મૂકી શકાય છે.

ઉપયોગનો કેસ: સિસ્ટમમાં, ઘણા જુદા જુદા ઑબ્જેક્ટ્સને સ્ટ્રિંગ ફોર્મેટમાં સીરીયલાઈઝ કરવાની જરૂર પડી શકે છે (દા.ત., લોગીંગ અથવા સ્ટોરેજ માટે). આ ઑબ્જેક્ટ્સ (`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. મિક્સિન્સ: કોડ પુનઃઉપયોગ માટે એક કમ્પોઝિશનલ અભિગમ

TypeScript ફક્ત સિંગલ વારસાને જ મંજૂરી આપે છે, જો તમે બહુવિધ સ્ત્રોતોમાંથી કોડનો પુનઃઉપયોગ કરવા માંગતા હોવ તો શું? આ તે છે જ્યાં મિક્સિન પેટર્ન આવે છે. મિક્સિન્સ એ ફંક્શન્સ છે જે કન્સ્ટ્રક્ટર લે છે અને નવું કન્સ્ટ્રક્ટર પરત કરે છે જે તેને નવી કાર્યક્ષમતા સાથે વિસ્તૃત કરે છે. તે કમ્પોઝિશનનું એક સ્વરૂપ છે જે તમને વર્ગમાં ક્ષમતાઓ "મિક્સ ઇન" કરવાની મંજૂરી આપે છે.

ઉપયોગનો કેસ: તમે `Timestamp` (જેમાં `createdAt`, `updatedAt` છે) અને `SoftDeletable` (જેમાં `deletedAt` ગુણધર્મ અને `softDelete()` પદ્ધતિ છે) વર્તણૂકોને બહુવિધ મોડેલ વર્ગોમાં ઉમેરવા માંગો છો.

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

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

// SoftDeletable Mixin
function SoftDeletable(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
              
            
          

નિષ્કર્ષ: ભવિષ્યને સુરક્ષિત TypeScript એપ્લિકેશનોનું નિર્માણ

TypeScriptમાં ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગમાં નિપુણતા મેળવવી એ સિન્ટેક્સને સમજવાથી લઈને ડિઝાઇન ફિલસૂફીને અપનાવવાની યાત્રા છે. વર્ગ માળખું, વારસો અને કમ્પોઝિશન સંબંધિત તમે જે પસંદગીઓ કરો છો તેની તમારી એપ્લિકેશનના લાંબા ગાળાના સ્વાસ્થ્ય પર ઊંડી અસર પડે છે.

તમારી વૈશ્વિક વિકાસ પ્રથા માટે અહીં મુખ્ય ટેકઅવે છે:

1. સ્તંભોથી શરૂઆત કરો: ખાતરી કરો કે તમારી પાસે એન્કેપ્સ્યુલેશન, એબ્સ્ટ્રેક્શન, વારસો અને પોલિમોરફિઝમની નક્કર સમજ છે. તેઓ OOPનો શબ્દભંડોળ છે.
2. વારસા પર કમ્પોઝિશનની તરફેણ કરો: આ સિદ્ધાંત તમને વધુ લવચીક, મોડ્યુલર અને પરીક્ષણ કરી શકાય તેવા કોડ તરફ દોરી જશે. કમ્પોઝિશનથી શરૂઆત કરો અને જ્યારે સ્પષ્ટ, સ્થિર "ઇઝ-એ" સંબંધ અસ્તિત્વમાં હોય ત્યારે જ વારસા સુધી પહોંચો.
3. કામ માટે યોગ્ય સાધનનો ઉપયોગ કરો:
   • સ્થિર વંશવેલોમાં સાચા વિશેષજ્ઞતા અને કોડ શેરિંગ માટે વારસાનો ઉપયોગ કરો.
   • કેટલાક અમલીકરણને શેર કરતી વખતે કરાર લાગુ કરીને વર્ગોના કુટુંબ માટે સામાન્ય આધાર વ્યાખ્યાયિત કરવા માટે એબ્સ્ટ્રેક્ટ વર્ગોનો ઉપયોગ કરો.
   • કોઈપણ વર્ગ દ્વારા અમલમાં મૂકી શકાય તેવા વર્તન માટે કરાર વ્યાખ્યાયિત કરવા માટે ઇન્ટરફેસોનો ઉપયોગ કરો, જે અત્યંત ડિસકપલિંગને પ્રોત્સાહન આપે છે.
   • જ્યારે તમારે સિંગલ વારસાની મર્યાદાઓને દૂર કરીને બહુવિધ સ્ત્રોતોમાંથી વર્ગમાં કાર્યક્ષમતાઓને કમ્પોઝ કરવાની જરૂર હોય ત્યારે મિક્સિન્સનો ઉપયોગ કરો.

આ પૅટર્ન્સ વિશે નિર્ણાયક રીતે વિચારીને અને તેમના ટ્રેડ-ઑફ્સને સમજીને, તમે TypeScript એપ્લિકેશનોને આર્કિટેક્ટ કરી શકો છો જે આજે માત્ર શક્તિશાળી અને કાર્યક્ષમ નથી, પરંતુ વર્ષો સુધી અનુકૂલન, વિસ્તરણ અને જાળવણી માટે પણ સરળ છે—તમે અથવા તમારી ટીમ વિશ્વમાં ગમે ત્યાં હોવ.