ടൈപ്പ്സ്ക്രിപ്റ്റ് വേരിയൻസ് അനോട്ടേഷനുകൾ: കരുത്തുറ്റ കോഡിനായി ടൈപ്പ് പാരാമീറ്റർ കൺസ്ട്രെയ്ന്റുകൾ മാസ്റ്റർ ചെയ്യുക

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

വേരിയൻസ് മനസ്സിലാക്കാം

ടൈപ്പുകൾ തമ്മിലുള്ള സബ്ടൈപ്പ് ബന്ധം, നിർമ്മിത ടൈപ്പുകൾ (ഉദാഹരണത്തിന്, ജെനറിക് ടൈപ്പുകൾ) തമ്മിലുള്ള സബ്ടൈപ്പ് ബന്ധത്തെ എങ്ങനെ ബാധിക്കുന്നു എന്ന് വേരിയൻസ് വിവരിക്കുന്നു. പ്രധാന പദങ്ങൾ നമുക്ക് വിശദീകരിക്കാം:

• കോവേരിയൻസ്: ഒരു ജെനറിക് ടൈപ്പ് Container<T> കോവേരിയന്റ് ആകുന്നത്, Subtype, Supertype-ന്റെ സബ്ടൈപ്പ് ആകുമ്പോഴെല്ലാം Container<Subtype>, Container<Supertype>-ന്റെ സബ്ടൈപ്പ് ആകുമ്പോഴാണ്. ഇത് സബ്ടൈപ്പ് ബന്ധം നിലനിർത്തുന്നു എന്ന് കരുതാം. പല ഭാഷകളിലും (TypeScript-ന്റെ ഫംഗ്ഷൻ പാരാമീറ്ററുകളിൽ നേരിട്ടല്ലെങ്കിലും), ജെനറിക് അറേകൾ കോവേരിയന്റ് ആണ്. ഉദാഹരണത്തിന്, Cat, Animal-നെ എക്സ്റ്റെൻഡ് ചെയ്യുന്നുവെങ്കിൽ, `Array<Cat>` എന്നത് `Array<Animal>`-ന്റെ സബ്ടൈപ്പ് പോലെ *പ്രവർത്തിക്കുന്നു* (എങ്കിലും റൺടൈം പിഴവുകൾ ഒഴിവാക്കാൻ TypeScript വ്യക്തമായ കോവേരിയൻസ് ഒഴിവാക്കുന്നു).
• കോൺട്രാവേരിയൻസ്: ഒരു ജെനറിക് ടൈപ്പ് Container<T> കോൺട്രാവേരിയന്റ് ആകുന്നത്, Subtype, Supertype-ന്റെ സബ്ടൈപ്പ് ആകുമ്പോഴെല്ലാം Container<Supertype>, Container<Subtype>-ന്റെ സബ്ടൈപ്പ് ആകുമ്പോഴാണ്. ഇത് സബ്ടൈപ്പ് ബന്ധത്തെ വിപരീതമാക്കുന്നു. ഫംഗ്ഷൻ പാരാമീറ്റർ ടൈപ്പുകൾ കോൺട്രാവേരിയൻസ് പ്രകടിപ്പിക്കുന്നു.
• ഇൻവേരിയൻസ്: ഒരു ജെനറിക് ടൈപ്പ് Container<T> ഇൻവേരിയന്റ് ആകുന്നത്, Subtype, Supertype-ന്റെ സബ്ടൈപ്പ് ആണെങ്കിൽ പോലും Container<Subtype>, Container<Supertype>-ന്റെ സബ്ടൈപ്പോ സൂപ്പർടൈപ്പോ അല്ലാതിരിക്കുമ്പോഴാണ്. TypeScript-ലെ ജെനറിക് ടൈപ്പുകൾ സാധാരണയായി ഇൻവേരിയന്റ് ആണ്, അല്ലാത്തപക്ഷം (പരോക്ഷമായി, ഫംഗ്ഷൻ പാരാമീറ്റർ നിയമങ്ങളിലൂടെ കോൺട്രാവേരിയൻസിനായി) വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ.

ഒരു ഉപമ ഉപയോഗിച്ച് ഇത് ഓർത്തുവെക്കാൻ എളുപ്പമാണ്: നായ്ക്കളുടെ കോളറുകൾ നിർമ്മിക്കുന്ന ഒരു ഫാക്ടറി പരിഗണിക്കുക. ഒരു കോവേരിയന്റ് ഫാക്ടറിക്ക് നായ്ക്കൾക്കുള്ള കോളറുകൾ നിർമ്മിക്കാൻ കഴിയുമെങ്കിൽ, എല്ലാത്തരം മൃഗങ്ങൾക്കും കോളറുകൾ നിർമ്മിക്കാൻ കഴിഞ്ഞേക്കും, ഇത് സബ്ടൈപ്പിംഗ് ബന്ധം നിലനിർത്തുന്നു. ഒരു കോൺട്രാവേരിയന്റ് ഫാക്ടറി എന്നത് നായ്ക്കളുടെ കോളറുകൾ ഉപയോഗിക്കാൻ കഴിയുമെങ്കിൽ, ഏത് തരം മൃഗങ്ങളുടെ കോളറും *ഉപയോഗിക്കാൻ* കഴിയുന്ന ഒന്നാണ്. ഫാക്ടറിക്ക് നായ്ക്കളുടെ കോളറുകൾ ഉപയോഗിച്ച് മാത്രമേ പ്രവർത്തിക്കാൻ കഴിയൂ, മറ്റൊന്നും സാധ്യമല്ലെങ്കിൽ, അത് മൃഗത്തിന്റെ തരത്തിന് ഇൻവേരിയന്റ് ആണ്.

വേരിയൻസ് എന്തിന് പ്രധാനമാണ്?

പ്രത്യേകിച്ച് ജെനറിക്സുമായി പ്രവർത്തിക്കുമ്പോൾ, ടൈപ്പ്-സേഫ് കോഡ് എഴുതുന്നതിന് വേരിയൻസ് മനസ്സിലാക്കുന്നത് നിർണായകമാണ്. കോവേരിയൻസ് അല്ലെങ്കിൽ കോൺട്രാവേരിയൻസ് തെറ്റായി അനുമാനിക്കുന്നത് റൺടൈം പിഴവുകളിലേക്ക് നയിച്ചേക്കാം, ഇത് തടയാനാണ് TypeScript-ന്റെ ടൈപ്പ് സിസ്റ്റം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ഈ തെറ്റായ ഉദാഹരണം പരിഗണിക്കുക (ജാവാസ്ക്രിപ്റ്റിൽ, ആശയം വ്യക്തമാക്കുന്നതിന് മാത്രം):

// ജാവാസ്ക്രിപ്റ്റ് ഉദാഹരണം (വിശദീകരണത്തിന് മാത്രം, TypeScript അല്ല)
function modifyAnimals(animals, modifier) {
  for (let i = 0; i < animals.length; i++) {
    animals[i] = modifier(animals[i]);
  }
}

function sound(animal) { return animal.sound(); }

function Cat(name) { this.name = name; this.sound = () => "Meow!"; }
Cat.prototype = Object.create({ sound: () => "Generic Animal Sound"});
function Animal(name) { this.name = name; this.sound = () => "Generic Animal Sound"; }

let cats = [new Cat("Whiskers"), new Cat("Mittens")];

// ഈ കോഡ് ഒരു പിശക് കാണിക്കും കാരണം Animal-നെ Cat അറേയിലേക്ക് അസൈൻ ചെയ്യുന്നത് ശരിയല്ല
//modifyAnimals(cats, (animal) => new Animal("Generic")); 

// ഇത് പ്രവർത്തിക്കും കാരണം Cat-നെ Cat അറേയിലേക്കാണ് അസൈൻ ചെയ്യുന്നത്
modifyAnimals(cats, (cat) => new Cat("Fuzzy"));

//cats.forEach(cat => console.log(cat.sound()));

ഈ ജാവാസ്ക്രിപ്റ്റ് ഉദാഹരണം നേരിട്ട് പ്രശ്നം കാണിക്കുന്നുണ്ടെങ്കിലും, TypeScript-ന്റെ ടൈപ്പ് സിസ്റ്റം സാധാരണയായി ഇത്തരത്തിലുള്ള നേരിട്ടുള്ള അസൈൻമെന്റ് *തടയുന്നു*. കൂടുതൽ സങ്കീർണ്ണമായ സാഹചര്യങ്ങളിൽ, പ്രത്യേകിച്ച് ഫംഗ്ഷൻ ടൈപ്പുകളും ജെനറിക് ഇന്റർഫേസുകളും കൈകാര്യം ചെയ്യുമ്പോൾ വേരിയൻസ് പരിഗണനകൾ പ്രധാനമാണ്.

ടൈപ്പ് പാരാമീറ്റർ കൺസ്ട്രെയ്ന്റുകൾ

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

extends കീവേഡ്

ടൈപ്പ് പാരാമീറ്റർ കൺസ്ട്രെയ്ന്റുകൾ നിർവചിക്കുന്നതിനുള്ള പ്രാഥമിക മാർഗ്ഗം extends കീവേഡ് ഉപയോഗിക്കുക എന്നതാണ്. ഒരു ടൈപ്പ് പാരാമീറ്റർ ഒരു പ്രത്യേക ടൈപ്പിന്റെ സബ്ടൈപ്പ് ആയിരിക്കണമെന്ന് ഈ കീവേഡ് വ്യക്തമാക്കുന്നു.

function logName<T extends { name: string }>(obj: T): void {
  console.log(obj.name);
}

// സാധുവായ ഉപയോഗം
logName({ name: "Alice", age: 30 });

// പിശക്: Argument of type '{}' is not assignable to parameter of type '{ name: string; }'.
// logName({});

ഈ ഉദാഹരണത്തിൽ, T എന്ന ടൈപ്പ് പാരാമീറ്റർ string തരത്തിലുള്ള name പ്രോപ്പർട്ടിയുള്ള ഒരു ടൈപ്പ് ആയിരിക്കണമെന്ന് നിർബന്ധിക്കുന്നു. ഇത് logName ഫംഗ്ഷന് അതിന്റെ ആർഗ്യുമെന്റിന്റെ name പ്രോപ്പർട്ടി സുരക്ഷിതമായി ആക്സസ് ചെയ്യാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.

ഇന്റർസെക്ഷൻ ടൈപ്പുകൾ ഉപയോഗിച്ചുള്ള ഒന്നിലധികം കൺസ്ട്രെയ്ന്റുകൾ

ഇന്റർസെക്ഷൻ ടൈപ്പുകൾ (&) ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒന്നിലധികം കൺസ്ട്രെയ്ന്റുകൾ സംയോജിപ്പിക്കാൻ കഴിയും. ഒരു ടൈപ്പ് പാരാമീറ്റർ ഒന്നിലധികം വ്യവസ്ഥകൾ പാലിക്കണമെന്ന് വ്യക്തമാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

interface Named {
  name: string;
}

interface Aged {
  age: number;
}

function logPerson<T extends Named & Aged>(person: T): void {
  console.log(`Name: ${person.name}, Age: ${person.age}`);
}

// സാധുവായ ഉപയോഗം
logPerson({ name: "Bob", age: 40 });

// പിശക്: Argument of type '{ name: string; }' is not assignable to parameter of type 'Named & Aged'.
// Property 'age' is missing in type '{ name: string; }' but required in type 'Aged'.
// logPerson({ name: "Charlie" });

ഇവിടെ, T എന്ന ടൈപ്പ് പാരാമീറ്റർ Named, Aged എന്നീ രണ്ട് ടൈപ്പുകളും ആയിരിക്കണമെന്ന് നിർബന്ധിക്കുന്നു. ഇത് logPerson ഫംഗ്ഷന് name, age എന്നീ രണ്ട് പ്രോപ്പർട്ടികളും സുരക്ഷിതമായി ആക്സസ് ചെയ്യാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.

ജെനറിക് ക്ലാസുകളിൽ ടൈപ്പ് കൺസ്ട്രെയ്ന്റുകൾ ഉപയോഗിക്കുന്നത്

ജെനറിക് ക്ലാസുകളിൽ പ്രവർത്തിക്കുമ്പോഴും ടൈപ്പ് കൺസ്ട്രെയ്ന്റുകൾ ഒരുപോലെ ഉപയോഗപ്രദമാണ്.

interface Printable {
  print(): void;
}

class Document<T extends Printable> {
  content: T;

  constructor(content: T) {
    this.content = content;
  }

  printDocument(): void {
    this.content.print();
  }
}

class Invoice implements Printable {
  invoiceNumber: string;

  constructor(invoiceNumber: string) {
    this.invoiceNumber = invoiceNumber;
  }

  print(): void {
    console.log(`Printing invoice: ${this.invoiceNumber}`);
  }
}

const myInvoice = new Invoice("INV-2023-123");
const document = new Document(myInvoice);
document.printDocument(); // ഔട്ട്പുട്ട്: Printing invoice: INV-2023-123

ഈ ഉദാഹരണത്തിൽ, Document ക്ലാസ് ജെനറിക് ആണ്, എന്നാൽ T എന്ന ടൈപ്പ് പാരാമീറ്റർ Printable ഇന്റർഫേസ് നടപ്പിലാക്കുന്ന ഒരു ടൈപ്പ് ആയിരിക്കണമെന്ന് നിർബന്ധിക്കുന്നു. ഇത് ഒരു Document-ന്റെ content ആയി ഉപയോഗിക്കുന്ന ഏതൊരു ഒബ്ജക്റ്റിനും ഒരു print മെത്തേഡ് ഉണ്ടാകുമെന്ന് ഉറപ്പ് നൽകുന്നു. വൈവിധ്യമാർന്ന ഫോർമാറ്റുകളോ ഭാഷകളോ ഉൾപ്പെടുന്ന പ്രിന്റിംഗ് ആവശ്യമുള്ള അന്താരാഷ്ട്ര സാഹചര്യങ്ങളിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്, കാരണം ഇതിന് ഒരു പൊതുവായ print ഇന്റർഫേസ് ആവശ്യമാണ്.

TypeScript-ലെ കോവേരിയൻസ്, കോൺട്രാവേരിയൻസ്, ഇൻവേരിയൻസ് (പുനഃപരിശോധന)

TypeScript-ന് വ്യക്തമായ വേരിയൻസ് അനോട്ടേഷനുകൾ (മറ്റ് ചില ഭാഷകളിലെ in, out പോലെ) ഇല്ലെങ്കിലും, ടൈപ്പ് പാരാമീറ്ററുകൾ എങ്ങനെ ഉപയോഗിക്കുന്നു എന്നതിനെ അടിസ്ഥാനമാക്കി അത് പരോക്ഷമായി വേരിയൻസ് കൈകാര്യം ചെയ്യുന്നു. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിലെ സൂക്ഷ്മതകൾ മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്, പ്രത്യേകിച്ച് ഫംഗ്ഷൻ പാരാമീറ്ററുകളുടെ കാര്യത്തിൽ.

ഫംഗ്ഷൻ പാരാമീറ്റർ ടൈപ്പുകൾ: കോൺട്രാവേരിയൻസ്

ഫംഗ്ഷൻ പാരാമീറ്റർ ടൈപ്പുകൾ കോൺട്രാവേരിയന്റ് ആണ്. ഇതിനർത്ഥം, പ്രതീക്ഷിക്കുന്നതിലും കൂടുതൽ പൊതുവായ ഒരു ടൈപ്പ് സ്വീകരിക്കുന്ന ഒരു ഫംഗ്ഷൻ നിങ്ങൾക്ക് സുരക്ഷിതമായി പാസ് ചെയ്യാൻ കഴിയും. കാരണം, ഒരു ഫംഗ്ഷന് ഒരു Supertype കൈകാര്യം ചെയ്യാൻ കഴിയുമെങ്കിൽ, അതിന് തീർച്ചയായും ഒരു Subtype കൈകാര്യം ചെയ്യാൻ കഴിയും.

interface Animal {
  name: string;
}

interface Cat extends Animal {
  meow(): void;
}

function feedAnimal(animal: Animal): void {
  console.log(`Feeding ${animal.name}`);
}

function feedCat(cat: Cat): void {
  console.log(`Feeding ${cat.name} (a cat)`);
  cat.meow();
}

// ഇത് സാധുവാണ് കാരണം ഫംഗ്ഷൻ പാരാമീറ്റർ ടൈപ്പുകൾ കോൺട്രാവേരിയന്റ് ആണ്
let feed: (animal: Animal) => void = feedCat; 

let genericAnimal:Animal = {name: "Generic Animal"};

feed(genericAnimal); // പ്രവർത്തിക്കും പക്ഷേ മ്യാവൂ എന്ന് ശബ്ദിക്കില്ല

let mittens: Cat = { name: "Mittens", meow: () => {console.log("Mittens meows");}};

feed(mittens); // ഇതും പ്രവർത്തിക്കും, യഥാർത്ഥ ഫംഗ്ഷൻ അനുസരിച്ച് മ്യാവൂ എന്ന് ശബ്ദിച്ചേക്കാം.

ഈ ഉദാഹരണത്തിൽ, feedCat എന്നത് (animal: Animal) => void എന്നതിന്റെ ഒരു സബ്ടൈപ്പ് ആണ്. കാരണം feedCat കൂടുതൽ നിർദ്ദിഷ്ടമായ ഒരു ടൈപ്പ് (Cat) സ്വീകരിക്കുന്നു, ഇത് ഫംഗ്ഷൻ പാരാമീറ്ററിലെ Animal ടൈപ്പുമായി ബന്ധപ്പെട്ട് ഇതിനെ കോൺട്രാവേരിയന്റ് ആക്കുന്നു. പ്രധാന ഭാഗം അസൈൻമെന്റ് ആണ്: let feed: (animal: Animal) => void = feedCat; എന്നത് സാധുവാണ്.

റിട്ടേൺ ടൈപ്പുകൾ: കോവേരിയൻസ്

ഫംഗ്ഷൻ റിട്ടേൺ ടൈപ്പുകൾ കോവേരിയന്റ് ആണ്. ഇതിനർത്ഥം, പ്രതീക്ഷിക്കുന്നതിലും കൂടുതൽ നിർദ്ദിഷ്ടമായ ഒരു ടൈപ്പ് നിങ്ങൾക്ക് സുരക്ഷിതമായി റിട്ടേൺ ചെയ്യാൻ കഴിയും. ഒരു ഫംഗ്ഷൻ ഒരു Animal റിട്ടേൺ ചെയ്യുമെന്ന് വാഗ്ദാനം ചെയ്താൽ, ഒരു Cat റിട്ടേൺ ചെയ്യുന്നത് തികച്ചും സ്വീകാര്യമാണ്.

function getAnimal(): Animal {
  return { name: "Generic Animal" };
}

function getCat(): Cat {
  return { name: "Whiskers", meow: () => { console.log("Whiskers meows"); } };
}

// ഇത് സാധുവാണ് കാരണം ഫംഗ്ഷൻ റിട്ടേൺ ടൈപ്പുകൾ കോവേരിയന്റ് ആണ്
let get: () => Animal = getCat;

let myAnimal: Animal = get();

console.log(myAnimal.name); // പ്രവർത്തിക്കും

// myAnimal.meow();  // പിശക്: 'Animal' എന്ന ടൈപ്പിൽ 'meow' എന്ന പ്രോപ്പർട്ടി നിലവിലില്ല.
// Cat-നിർദ്ദിഷ്ട പ്രോപ്പർട്ടികൾ ആക്സസ് ചെയ്യാൻ നിങ്ങൾ ഒരു ടൈപ്പ് അസേർഷൻ ഉപയോഗിക്കേണ്ടതുണ്ട്

if ((myAnimal as Cat).meow) {
  (myAnimal as Cat).meow(); // Whiskers meows
}

ഇവിടെ, getCat എന്നത് () => Animal എന്നതിന്റെ ഒരു സബ്ടൈപ്പ് ആണ്, കാരണം അത് കൂടുതൽ നിർദ്ദിഷ്ടമായ ഒരു ടൈപ്പ് (Cat) റിട്ടേൺ ചെയ്യുന്നു. let get: () => Animal = getCat; എന്ന അസൈൻമെന്റ് സാധുവാണ്.

അറേകളും ജെനറിക്സും: ഇൻവേരിയൻസ് (മിക്കവാറും)

TypeScript അറേകളെയും മിക്ക ജെനറിക് ടൈപ്പുകളെയും ഡിഫോൾട്ടായി ഇൻവേരിയന്റ് ആയി കണക്കാക്കുന്നു. ഇതിനർത്ഥം, Cat, Animal-നെ എക്സ്റ്റെൻഡ് ചെയ്താലും Array<Cat> എന്നത് Array<Animal>-ന്റെ സബ്ടൈപ്പായി കണക്കാക്കില്ല. റൺടൈം പിഴവുകൾ തടയുന്നതിനുള്ള ഒരു ബോധപൂർവമായ ഡിസൈൻ തീരുമാനമാണിത്. മറ്റ് പല ഭാഷകളിലും അറേകൾ കോവേരിയന്റ് ആയി *പ്രവർത്തിക്കുന്നുണ്ടെങ്കിലും*, സുരക്ഷയ്ക്കായി TypeScript അവയെ ഇൻവേരിയന്റ് ആക്കുന്നു.

let animals: Animal[] = [{ name: "Generic Animal" }];
let cats: Cat[] = [{ name: "Whiskers", meow: () => { console.log("Whiskers meows"); } }];

// പിശക്: Type 'Cat[]' is not assignable to type 'Animal[]'.
// Type 'Cat' is not assignable to type 'Animal'.
// Property 'meow' is missing in type 'Animal' but required in type 'Cat'.
// animals = cats; // അനുവദിച്ചാൽ ഇത് പ്രശ്നങ്ങൾക്ക് കാരണമാകും!

//എങ്കിലും ഇത് പ്രവർത്തിക്കും
animals[0] = cats[0];

console.log(animals[0].name);

//animals[0].meow();  // പിശക് - animals[0] നെ Animal ടൈപ്പ് ആയിട്ടാണ് കാണുന്നത് അതിനാൽ meow ലഭ്യമല്ല

(animals[0] as Cat).meow(); // Cat-നിർദ്ദിഷ്ട മെത്തേഡുകൾ ഉപയോഗിക്കാൻ ടൈപ്പ് അസേർഷൻ ആവശ്യമാണ്

animals = cats; എന്ന അസൈൻമെന്റ് അനുവദിക്കുന്നത് സുരക്ഷിതമല്ലാത്തതിനാലാണ്, കാരണം നിങ്ങൾക്ക് animals അറേയിലേക്ക് ഒരു ജെനറിക് Animal ചേർക്കാൻ കഴിയും, ഇത് cats അറേയുടെ ടൈപ്പ് സുരക്ഷയെ ലംഘിക്കും (അതിൽ Cat ഒബ്ജക്റ്റുകൾ മാത്രമേ അടങ്ങാൻ പാടുള്ളൂ). ഇക്കാരണത്താൽ, TypeScript അറേകൾ ഇൻവേരിയന്റ് ആണെന്ന് അനുമാനിക്കുന്നു.

പ്രായോഗിക ഉദാഹരണങ്ങളും ഉപയോഗ സാഹചര്യങ്ങളും

ജെനറിക് റിപ്പോസിറ്ററി പാറ്റേൺ

ഡാറ്റാ ആക്‌സസ്സിനായി ഒരു ജെനറിക് റിപ്പോസിറ്ററി പാറ്റേൺ പരിഗണിക്കുക. നിങ്ങൾക്ക് ഒരു അടിസ്ഥാന എന്റിറ്റി ടൈപ്പും ആ ടൈപ്പിൽ പ്രവർത്തിക്കുന്ന ഒരു ജെനറിക് റിപ്പോസിറ്ററി ഇന്റർഫേസും ഉണ്ടായിരിക്കാം.

interface Entity {
  id: string;
}

interface Repository<T extends Entity> {
  getById(id: string): T | undefined;
  save(entity: T): void;
  delete(id: string): void;
}

class InMemoryRepository<T extends Entity> implements Repository<T> {
  private data: { [id: string]: T } = {};

  getById(id: string): T | undefined {
    return this.data[id];
  }

  save(entity: T): void {
    this.data[entity.id] = entity;
  }

  delete(id: string): void {
    delete this.data[id];
  }
}

interface Product extends Entity {
  name: string;
  price: number;
}

const productRepository: Repository<Product> = new InMemoryRepository<Product>();

const newProduct: Product = { id: "123", name: "Laptop", price: 1200 };
productRepository.save(newProduct);

const retrievedProduct = productRepository.getById("123");
if (retrievedProduct) {
  console.log(`Retrieved product: ${retrievedProduct.name}`);
}

T extends Entity എന്ന ടൈപ്പ് കൺസ്ട്രെയ്ന്റ്, റിപ്പോസിറ്ററിക്ക് id പ്രോപ്പർട്ടിയുള്ള എന്റിറ്റികളിൽ മാത്രമേ പ്രവർത്തിക്കാൻ കഴിയൂ എന്ന് ഉറപ്പാക്കുന്നു. ഇത് ഡാറ്റയുടെ സമഗ്രതയും സ്ഥിരതയും നിലനിർത്താൻ സഹായിക്കുന്നു. Product ഇന്റർഫേസിനുള്ളിൽ വ്യത്യസ്ത കറൻസി ടൈപ്പുകൾ കൈകാര്യം ചെയ്തുകൊണ്ട് അന്താരാഷ്ട്രവൽക്കരണവുമായി പൊരുത്തപ്പെടുന്നതിനും വിവിധ ഫോർമാറ്റുകളിലുള്ള ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനും ഈ പാറ്റേൺ ഉപയോഗപ്രദമാണ്.

ജെനറിക് പേലോഡുകൾ ഉപയോഗിച്ചുള്ള ഇവന്റ് ഹാൻഡ്‌ലിംഗ്

ഇവന്റ് ഹാൻഡ്‌ലിംഗ് ആണ് മറ്റൊരു സാധാരണ ഉപയോഗം. ഒരു നിർദ്ദിഷ്ട പേലോഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ജെനറിക് ഇവന്റ് ടൈപ്പ് നിർവചിക്കാൻ കഴിയും.

interface Event<T> {
  type: string;
  payload: T;
}

interface UserCreatedEventPayload {
  userId: string;
  email: string;
}

interface ProductPurchasedEventPayload {
  productId: string;
  quantity: number;
}

function handleEvent<T>(event: Event<T>): void {
  console.log(`Handling event of type: ${event.type}`);
  console.log(`Payload: ${JSON.stringify(event.payload)}`);
}

const userCreatedEvent: Event<UserCreatedEventPayload> = {
  type: "user.created",
  payload: { userId: "user123", email: "alice@example.com" },
};

const productPurchasedEvent: Event<ProductPurchasedEventPayload> = {
  type: "product.purchased",
  payload: { productId: "product456", quantity: 2 },
};

handleEvent(userCreatedEvent);
handleEvent(productPurchasedEvent);

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

ഒരു ജെനറിക് ഡാറ്റാ ട്രാൻസ്ഫോർമേഷൻ പൈപ്പ്ലൈൻ നിർമ്മിക്കുന്നു

ഒരു ഫോർമാറ്റിൽ നിന്ന് മറ്റൊന്നിലേക്ക് ഡാറ്റ മാറ്റേണ്ട ഒരു സാഹചര്യം പരിഗണിക്കുക. ഇൻപുട്ട്, ഔട്ട്പുട്ട് ടൈപ്പുകൾ ട്രാൻസ്ഫോർമേഷൻ ഫംഗ്ഷനുകളുമായി പൊരുത്തപ്പെടുന്നുവെന്ന് ഉറപ്പാക്കാൻ ടൈപ്പ് പാരാമീറ്റർ കൺസ്ട്രെയ്ന്റുകൾ ഉപയോഗിച്ച് ഒരു ജെനറിക് ഡാറ്റാ ട്രാൻസ്ഫോർമേഷൻ പൈപ്പ്ലൈൻ നടപ്പിലാക്കാൻ കഴിയും.

interface DataTransformer<TInput, TOutput> {
  transform(input: TInput): TOutput;
}

function processData<TInput, TOutput, TIntermediate>(
  input: TInput,
  transformer1: DataTransformer<TInput, TIntermediate>,
  transformer2: DataTransformer<TIntermediate, TOutput>
): TOutput {
  const intermediateData = transformer1.transform(input);
  const outputData = transformer2.transform(intermediateData);
  return outputData;
}

interface RawUserData {
  firstName: string;
  lastName: string;
}

interface UserData {
  fullName: string;
  email: string;
}

class RawToIntermediateTransformer implements DataTransformer<RawUserData, {name: string}> {
    transform(input: RawUserData): {name: string} {
        return { name: `${input.firstName} ${input.lastName}`};
    }
}

class IntermediateToUserTransformer implements DataTransformer<{name: string}, UserData> {
    transform(input: {name: string}): UserData {
        return {fullName: input.name, email: `${input.name.replace(" ", ".")}@example.com`};
    }
}

const rawData: RawUserData = { firstName: "John", lastName: "Doe" };

const userData: UserData = processData(
  rawData,
  new RawToIntermediateTransformer(),
  new IntermediateToUserTransformer()
);

console.log(userData);

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

മികച്ച രീതികളും പരിഗണനകളും

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

ഉപസംഹാരം

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