ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ മാപ്പ്ഡ്, കണ്ടീഷണൽ ടൈപ്പുകളിൽ വൈദഗ്ദ്ധ്യം നേടാം

ജാവാസ്ക്രിപ്റ്റിന്റെ ഒരു സൂപ്പർസെറ്റായ ടൈപ്പ്സ്ക്രിപ്റ്റ്, ശക്തവും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിന് മികച്ച ഫീച്ചറുകൾ നൽകുന്നു. ഈ ഫീച്ചറുകളിൽ, അഡ്വാൻസ്ഡ് ടൈപ്പ് മാനിപ്പുലേഷന് ആവശ്യമായ പ്രധാന ടൂളുകളാണ് മാപ്പ്ഡ് ടൈപ്പുകളും (Mapped Types) കണ്ടീഷണൽ ടൈപ്പുകളും (Conditional Types). ഈ ഗൈഡ് ഈ ആശയങ്ങളെക്കുറിച്ച് സമഗ്രമായ ഒരു അവലോകനം നൽകുന്നു, അവയുടെ സിന്റാക്സ്, പ്രായോഗിക പ്രയോഗങ്ങൾ, നൂതന ഉപയോഗ രീതികൾ എന്നിവ പര്യവേക്ഷണം ചെയ്യുന്നു. നിങ്ങൾ പരിചയസമ്പന്നനായ ഒരു ടൈപ്പ്സ്ക്രിപ്റ്റ് ഡെവലപ്പർ ആണെങ്കിലും അല്ലെങ്കിൽ നിങ്ങളുടെ യാത്ര ആരംഭിക്കുന്ന ആളാണെങ്കിലും, ഈ ഫീച്ചറുകൾ ഫലപ്രദമായി ഉപയോഗിക്കുന്നതിനുള്ള അറിവ് ഈ ലേഖനം നിങ്ങൾക്ക് നൽകും.

എന്താണ് മാപ്പ്ഡ് ടൈപ്പുകൾ?

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

അടിസ്ഥാന സിന്റാക്സ്

ഒരു മാപ്പ്ഡ് ടൈപ്പിന്റെ സിന്റാക്സ് താഴെ പറയുന്നവയാണ്:

type NewType<T> = {
  [K in keyof T]: Transformation;
};

• T: നിങ്ങൾ മാപ്പ് ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ഇൻപുട്ട് ടൈപ്പ്.
• K in keyof T: ഇൻപുട്ട് ടൈപ്പായ T-യിലെ ഓരോ കീയിലൂടെയും ഇത് കടന്നുപോകുന്നു. keyof T എന്നത് T-യിലെ എല്ലാ പ്രോപ്പർട്ടി നാമങ്ങളുടെയും ഒരു യൂണിയൻ ഉണ്ടാക്കുന്നു, കൂടാതെ K ഓരോ കീയെയും പ്രതിനിധീകരിക്കുന്നു.
• Transformation: ഓരോ പ്രോപ്പർട്ടിയിലും നിങ്ങൾ പ്രയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന രൂപാന്തരം. ഇത് ഒരു മോഡിഫയർ (readonly അല്ലെങ്കിൽ ? പോലുള്ളവ) ചേർക്കുന്നതോ, ടൈപ്പ് മാറ്റുന്നതോ, അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും ആകാം.

പ്രായോഗിക ഉദാഹരണങ്ങൾ

പ്രോപ്പർട്ടികൾ റീഡ്-ഓൺലി ആക്കുന്നു

ഒരു യൂസർ പ്രൊഫൈലിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു ഇന്റർഫേസ് നിങ്ങൾക്കുണ്ടെന്ന് കരുതുക:

interface UserProfile {
  name: string;
  age: number;
  email: string;
}

എല്ലാ പ്രോപ്പർട്ടികളും റീഡ്-ഓൺലി ആയ ഒരു പുതിയ ടൈപ്പ് നിങ്ങൾക്ക് സൃഷ്ടിക്കാൻ കഴിയും:

type ReadOnlyUserProfile = {
  readonly [K in keyof UserProfile]: UserProfile[K];
};

ഇപ്പോൾ, ReadOnlyUserProfile-ന് UserProfile-ന്റെ അതേ പ്രോപ്പർട്ടികൾ ഉണ്ടാകും, പക്ഷേ അവയെല്ലാം റീഡ്-ഓൺലി ആയിരിക്കും.

പ്രോപ്പർട്ടികൾ ഓപ്ഷണൽ ആക്കുന്നു

അതുപോലെ, നിങ്ങൾക്ക് എല്ലാ പ്രോപ്പർട്ടികളും ഓപ്ഷണൽ ആക്കാം:

type OptionalUserProfile = {
  [K in keyof UserProfile]?: UserProfile[K];
};

OptionalUserProfile-ന് UserProfile-ന്റെ എല്ലാ പ്രോപ്പർട്ടികളും ഉണ്ടാകും, പക്ഷേ ഓരോ പ്രോപ്പർട്ടിയും ഓപ്ഷണൽ ആയിരിക്കും.

പ്രോപ്പർട്ടി ടൈപ്പുകൾ പരിഷ്കരിക്കുന്നു

ഓരോ പ്രോപ്പർട്ടിയുടെയും ടൈപ്പ് നിങ്ങൾക്ക് പരിഷ്കരിക്കാനും കഴിയും. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് എല്ലാ പ്രോപ്പർട്ടികളെയും സ്ട്രിംഗുകളാക്കി മാറ്റാൻ കഴിയും:

type StringifiedUserProfile = {
  [K in keyof UserProfile]: string;
};

ഈ സാഹചര്യത്തിൽ, StringifiedUserProfile-ലെ എല്ലാ പ്രോപ്പർട്ടികളും string ടൈപ്പിലായിരിക്കും.

എന്താണ് കണ്ടീഷണൽ ടൈപ്പുകൾ?

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

അടിസ്ഥാന സിന്റാക്സ്

ഒരു കണ്ടീഷണൽ ടൈപ്പിന്റെ സിന്റാക്സ് താഴെ പറയുന്നവയാണ്:

T extends U ? X : Y

• T: പരിശോധിക്കപ്പെടുന്ന ടൈപ്പ്.
• U: T എക്സ്റ്റൻഡ് ചെയ്യുന്ന ടൈപ്പ് (വ്യവസ്ഥ).
• X: T, U-വിനെ എക്സ്റ്റൻഡ് ചെയ്യുകയാണെങ്കിൽ (വ്യവസ്ഥ ശരിയാണെങ്കിൽ) തിരികെ നൽകേണ്ട ടൈപ്പ്.
• Y: T, U-വിനെ എക്സ്റ്റൻഡ് ചെയ്യുന്നില്ലെങ്കിൽ (വ്യവസ്ഥ തെറ്റാണെങ്കിൽ) തിരികെ നൽകേണ്ട ടൈപ്പ്.

പ്രായോഗിക ഉദാഹരണങ്ങൾ

ഒരു ടൈപ്പ് സ്ട്രിംഗ് ആണോ എന്ന് നിർണ്ണയിക്കുന്നു

ഇൻപുട്ട് ടൈപ്പ് ഒരു സ്ട്രിംഗ് ആണെങ്കിൽ string എന്നും അല്ലെങ്കിൽ number എന്നും തിരികെ നൽകുന്ന ഒരു ടൈപ്പ് നമുക്ക് ഉണ്ടാക്കാം:

type StringOrNumber<T> = T extends string ? string : number;

type Result1 = StringOrNumber<string>;  // string
type Result2 = StringOrNumber<number>;  // number
type Result3 = StringOrNumber<boolean>; // number

ഒരു യൂണിയനിൽ നിന്ന് ടൈപ്പ് വേർതിരിച്ചെടുക്കുന്നു

ഒരു യൂണിയൻ ടൈപ്പിൽ നിന്ന് ഒരു പ്രത്യേക ടൈപ്പ് വേർതിരിച്ചെടുക്കാൻ നിങ്ങൾക്ക് കണ്ടീഷണൽ ടൈപ്പുകൾ ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, നോൺ-നള്ളബിൾ ടൈപ്പുകൾ വേർതിരിച്ചെടുക്കാൻ:

type NonNullable<T> = T extends null | undefined ? never : T;

type Result4 = NonNullable<string | null | undefined>; // string

ഇവിടെ, T എന്നത് null അല്ലെങ്കിൽ undefined ആണെങ്കിൽ, ടൈപ്പ് never ആയി മാറുന്നു, ഇത് ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ യൂണിയൻ ടൈപ്പ് സിംപ്ലിഫിക്കേഷൻ വഴി ഫിൽട്ടർ ചെയ്യപ്പെടുന്നു.

ടൈപ്പുകൾ അനുമാനിക്കുന്നു (Inferring)

infer എന്ന കീവേഡ് ഉപയോഗിച്ച് ടൈപ്പുകൾ അനുമാനിക്കാനും കണ്ടീഷണൽ ടൈപ്പുകൾ ഉപയോഗിക്കാം. കൂടുതൽ സങ്കീർണ്ണമായ ഒരു ടൈപ്പ് ഘടനയിൽ നിന്ന് ഒരു ടൈപ്പ് വേർതിരിച്ചെടുക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

function myFunction(x: number): string {
  return x.toString();
}

type Result5 = ReturnType<typeof myFunction>; // string

ഈ ഉദാഹരണത്തിൽ, ReturnType ഒരു ഫംഗ്‌ഷന്റെ റിട്ടേൺ ടൈപ്പ് വേർതിരിച്ചെടുക്കുന്നു. T എന്നത് ഏതെങ്കിലും ആർഗ്യുമെന്റുകൾ എടുക്കുകയും R എന്ന ടൈപ്പ് തിരികെ നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷനാണോ എന്ന് ഇത് പരിശോധിക്കുന്നു. അങ്ങനെയാണെങ്കിൽ, അത് R തിരികെ നൽകുന്നു; അല്ലാത്തപക്ഷം, അത് any തിരികെ നൽകുന്നു.

മാപ്പ്ഡ് ടൈപ്പുകളും കണ്ടീഷണൽ ടൈപ്പുകളും സംയോജിപ്പിക്കുന്നു

മാപ്പ്ഡ് ടൈപ്പുകളുടെയും കണ്ടീഷണൽ ടൈപ്പുകളുടെയും യഥാർത്ഥ ശക്തി അവയെ സംയോജിപ്പിക്കുമ്പോൾ ആണ് ലഭിക്കുന്നത്. ഇത് വളരെ ഫ്ലെക്സിബിളും എക്സ്പ്രെസ്സീവുമായ ടൈപ്പ് രൂപാന്തരങ്ങൾ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഉദാഹരണം: ഡീപ്പ് റീഡ്ഓൺലി (Deep Readonly)

ഒരു ഒബ്‌ജക്റ്റിന്റെ നെസ്റ്റഡ് പ്രോപ്പർട്ടികൾ ഉൾപ്പെടെയുള്ള എല്ലാ പ്രോപ്പർട്ടികളെയും റീഡ്-ഓൺലി ആക്കുന്ന ഒരു ടൈപ്പ് ഉണ്ടാക്കുക എന്നത് ഒരു സാധാരണ ഉപയോഗമാണ്. ഒരു റിക്കേഴ്സീവ് കണ്ടീഷണൽ ടൈപ്പ് ഉപയോഗിച്ച് ഇത് നേടാനാകും.

type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};

interface Company {
  name: string;
  address: {
    street: string;
    city: string;
  };
}

type ReadonlyCompany = DeepReadonly<Company>;

ഇവിടെ, DeepReadonly എല്ലാ പ്രോപ്പർട്ടികളിലും അവയുടെ നെസ്റ്റഡ് പ്രോപ്പർട്ടികളിലും readonly മോഡിഫയർ ആവർത്തിച്ച് പ്രയോഗിക്കുന്നു. ഒരു പ്രോപ്പർട്ടി ഒരു ഒബ്‌ജക്റ്റ് ആണെങ്കിൽ, അത് ആ ഒബ്‌ജക്റ്റിൽ DeepReadonly വീണ്ടും വിളിക്കുന്നു. അല്ലാത്തപക്ഷം, അത് പ്രോപ്പർട്ടിയിൽ readonly മോഡിഫയർ പ്രയോഗിക്കുന്നു.

ഉദാഹരണം: ടൈപ്പ് അനുസരിച്ച് പ്രോപ്പർട്ടികൾ ഫിൽട്ടർ ചെയ്യുന്നു

ഒരു പ്രത്യേക ടൈപ്പിലുള്ള പ്രോപ്പർട്ടികൾ മാത്രം ഉൾക്കൊള്ളുന്ന ഒരു ടൈപ്പ് ഉണ്ടാക്കണമെന്ന് കരുതുക. ഇത് നേടുന്നതിന് നിങ്ങൾക്ക് മാപ്പ്ഡ് ടൈപ്പുകളും കണ്ടീഷണൽ ടൈപ്പുകളും സംയോജിപ്പിക്കാം.

type FilterByType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K];
};

interface Person {
  name: string;
  age: number;
  isEmployed: boolean;
}

type StringProperties = FilterByType<Person, string>; // { name: string; }

type NonStringProperties = Omit<Person, keyof StringProperties>;

ഈ ഉദാഹരണത്തിൽ, FilterByType T-യുടെ പ്രോപ്പർട്ടികളിലൂടെ കടന്നുപോയി ഓരോ പ്രോപ്പർട്ടിയുടെയും ടൈപ്പ് U-വിനെ എക്സ്റ്റൻഡ് ചെയ്യുന്നുണ്ടോ എന്ന് പരിശോധിക്കുന്നു. അങ്ങനെയാണെങ്കിൽ, അത് ഫലമായുണ്ടാകുന്ന ടൈപ്പിൽ പ്രോപ്പർട്ടി ഉൾപ്പെടുത്തുന്നു; അല്ലാത്തപക്ഷം, കീയോടു never-ലേക്ക് മാപ്പ് ചെയ്തുകൊണ്ട് അത് ഒഴിവാക്കുന്നു. കീകൾ റീമാപ്പ് ചെയ്യാൻ "as" ഉപയോഗിക്കുന്നത് ശ്രദ്ധിക്കുക. തുടർന്ന്, യഥാർത്ഥ ഇന്റർഫേസിൽ നിന്ന് സ്ട്രിംഗ് പ്രോപ്പർട്ടികൾ നീക്കംചെയ്യാൻ ഞങ്ങൾ `Omit`-ഉം `keyof StringProperties`-ഉം ഉപയോഗിക്കുന്നു.

നൂതന ഉപയോഗ രീതികളും പാറ്റേണുകളും

അടിസ്ഥാന ഉദാഹരണങ്ങൾക്കപ്പുറം, വളരെ കസ്റ്റമൈസ് ചെയ്യാവുന്നതും ടൈപ്പ്-സേഫ് ആയതുമായ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാൻ കൂടുതൽ വിപുലമായ സാഹചര്യങ്ങളിൽ മാപ്പ്ഡ് ടൈപ്പുകളും കണ്ടീഷണൽ ടൈപ്പുകളും ഉപയോഗിക്കാം.

ഡിസ്ട്രിബ്യൂട്ടീവ് കണ്ടീഷണൽ ടൈപ്പുകൾ

പരിശോധിക്കപ്പെടുന്ന ടൈപ്പ് ഒരു യൂണിയൻ ടൈപ്പ് ആകുമ്പോൾ കണ്ടീഷണൽ ടൈപ്പുകൾ ഡിസ്ട്രിബ്യൂട്ടീവ് ആകുന്നു. ഇതിനർത്ഥം, വ്യവസ്ഥ യൂണിയനിലെ ഓരോ അംഗത്തിനും தனித்தனியாக പ്രയോഗിക്കുകയും, ഫലങ്ങൾ ഒരു പുതിയ യൂണിയൻ ടൈപ്പിലേക്ക് സംയോജിപ്പിക്കുകയും ചെയ്യുന്നു.

type ToArray<T> = T extends any ? T[] : never;

type Result6 = ToArray<string | number>; // string[] | number[]

ഈ ഉദാഹരണത്തിൽ, ToArray എന്നത് string | number എന്ന യൂണിയനിലെ ഓരോ അംഗത്തിനും വെവ്വേറെയായി പ്രയോഗിക്കുന്നു, അതിന്റെ ഫലമായി string[] | number[] ലഭിക്കുന്നു. ഈ വ്യവസ്ഥ ഡിസ്ട്രിബ്യൂട്ടീവ് അല്ലായിരുന്നുവെങ്കിൽ, ഫലം (string | number)[] ആകുമായിരുന്നു.

യൂട്ടിലിറ്റി ടൈപ്പുകൾ ഉപയോഗിക്കുന്നു

മാപ്പ്ഡ് ടൈപ്പുകളും കണ്ടീഷണൽ ടൈപ്പുകളും ഉപയോഗിക്കുന്ന നിരവധി ബിൽറ്റ്-ഇൻ യൂട്ടിലിറ്റി ടൈപ്പുകൾ ടൈപ്പ്സ്ക്രിപ്റ്റ് നൽകുന്നു. കൂടുതൽ സങ്കീർണ്ണമായ ടൈപ്പ് രൂപാന്തരീകരണങ്ങൾക്കുള്ള ബിൽഡിംഗ് ബ്ലോക്കുകളായി ഈ യൂട്ടിലിറ്റി ടൈപ്പുകൾ ഉപയോഗിക്കാം.

• Partial<T>: T-യുടെ എല്ലാ പ്രോപ്പർട്ടികളും ഓപ്ഷണലാക്കുന്നു.
• Required<T>: T-യുടെ എല്ലാ പ്രോപ്പർട്ടികളും നിർബന്ധമാക്കുന്നു.
• Readonly<T>: T-യുടെ എല്ലാ പ്രോപ്പർട്ടികളും റീഡ്-ഓൺലി ആക്കുന്നു.
• Pick<T, K>: T-യിൽ നിന്ന് K എന്ന പ്രോപ്പർട്ടികളുടെ ഒരു സെറ്റ് തിരഞ്ഞെടുക്കുന്നു.
• Omit<T, K>: T-യിൽ നിന്ന് K എന്ന പ്രോപ്പർട്ടികളുടെ ഒരു സെറ്റ് നീക്കംചെയ്യുന്നു.
• Record<K, T>: T ടൈപ്പിലുള്ള K പ്രോപ്പർട്ടികളുടെ ഒരു സെറ്റുള്ള ഒരു ടൈപ്പ് നിർമ്മിക്കുന്നു.
• Exclude<T, U>: T-യിൽ നിന്ന് U-വിലേക്ക് അസൈൻ ചെയ്യാൻ കഴിയുന്ന എല്ലാ ടൈപ്പുകളെയും ഒഴിവാക്കുന്നു.
• Extract<T, U>: T-യിൽ നിന്ന് U-വിലേക്ക് അസൈൻ ചെയ്യാൻ കഴിയുന്ന എല്ലാ ടൈപ്പുകളെയും വേർതിരിച്ചെടുക്കുന്നു.
• NonNullable<T>: T-യിൽ നിന്ന് null, undefined എന്നിവയെ ഒഴിവാക്കുന്നു.
• Parameters<T>: ഒരു ഫംഗ്ഷൻ ടൈപ്പായ T-യുടെ പാരാമീറ്ററുകൾ നേടുന്നു.
• ReturnType<T>: ഒരു ഫംഗ്ഷൻ ടൈപ്പായ T-യുടെ റിട്ടേൺ ടൈപ്പ് നേടുന്നു.
• InstanceType<T>: ഒരു കൺസ്ട്രക്റ്റർ ഫംഗ്ഷൻ ടൈപ്പായ T-യുടെ ഇൻസ്റ്റൻസ് ടൈപ്പ് നേടുന്നു.

ഈ യൂട്ടിലിറ്റി ടൈപ്പുകൾ സങ്കീർണ്ണമായ ടൈപ്പ് മാനിപ്പുലേഷനുകൾ ലളിതമാക്കാൻ കഴിയുന്ന ശക്തമായ ഉപകരണങ്ങളാണ്. ഉദാഹരണത്തിന്, ചില പ്രോപ്പർട്ടികൾ മാത്രം ഓപ്ഷണലാക്കുന്ന ഒരു ടൈപ്പ് സൃഷ്ടിക്കാൻ നിങ്ങൾക്ക് Pick-ഉം Partial-ഉം സംയോജിപ്പിക്കാം:

type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
}

type OptionalDescriptionProduct = Optional<Product, "description">;

ഈ ഉദാഹരണത്തിൽ, OptionalDescriptionProduct-ന് Product-ന്റെ എല്ലാ പ്രോപ്പർട്ടികളുമുണ്ട്, എന്നാൽ description പ്രോപ്പർട്ടി ഓപ്ഷണലാണ്.

ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പുകൾ ഉപയോഗിക്കുന്നു

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

type Prefix<T, P extends string> = {
  [K in keyof T as `${P}${string & K}`]: T[K];
};

interface Settings {
  apiUrl: string;
  timeout: number;
}

type PrefixedSettings = Prefix<Settings, "data_">;

ഈ ഉദാഹരണത്തിൽ, PrefixedSettings-ന് data_apiUrl, data_timeout എന്നീ പ്രോപ്പർട്ടികൾ ഉണ്ടായിരിക്കും.

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

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

ഉപസംഹാരം

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

നിങ്ങൾ ടൈപ്പ്സ്ക്രിപ്റ്റ് യാത്ര തുടരുമ്പോൾ, ഔദ്യോഗിക ടൈപ്പ്സ്ക്രിപ്റ്റ് ഡോക്യുമെന്റേഷൻ, ഓൺലൈൻ കമ്മ്യൂണിറ്റികൾ, ഓപ്പൺ സോഴ്‌സ് പ്രോജക്റ്റുകൾ എന്നിവയുൾപ്പെടെ ലഭ്യമായ വിഭവങ്ങളുടെ സമൃദ്ധി പ്രയോജനപ്പെടുത്താൻ ഓർമ്മിക്കുക. മാപ്പ്ഡ് ടൈപ്പുകളുടെയും കണ്ടീഷണൽ ടൈപ്പുകളുടെയും ശക്തിയെ സ്വീകരിക്കുക, ടൈപ്പുമായി ബന്ധപ്പെട്ട ഏറ്റവും വെല്ലുവിളി നിറഞ്ഞ പ്രശ്‌നങ്ങളെപ്പോലും നേരിടാൻ നിങ്ങൾ സജ്ജരാകും.