M

MLOG

മലയാളം

ടൈപ്പ്സ്ക്രിപ്റ്റിന്റെ യൂട്ടിലിറ്റി ടൈപ്പുകൾ ഉപയോഗിച്ച് ടൈപ്പ് ട്രാൻസ്ഫോർമേഷനുകൾ നടത്തുക, കോഡിന്റെ പുനരുപയോഗവും ടൈപ്പ് സുരക്ഷയും മെച്ചപ്പെടുത്തുക.

ടൈപ്പ്സ്ക്രിപ്റ്റ് യൂട്ടിലിറ്റി ടൈപ്പുകൾ: ബിൽറ്റ്-ഇൻ ടൈപ്പ് മാനിപ്പുലേഷൻ ടൂളുകൾ

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

എന്താണ് ടൈപ്പ്സ്ക്രിപ്റ്റ് യൂട്ടിലിറ്റി ടൈപ്പുകൾ?

യൂട്ടിലിറ്റി ടൈപ്പുകൾ എന്നത് നിലവിലുള്ള ടൈപ്പുകളെ പുതിയ ടൈപ്പുകളാക്കി മാറ്റുന്ന മുൻകൂട്ടി നിർവചിച്ച ടൈപ്പ് ഓപ്പറേറ്ററുകളാണ്. അവ ടൈപ്പ്സ്ക്രിപ്റ്റ് ഭാഷയിൽ നിർമ്മിച്ചിട്ടുള്ളതാണ്, കൂടാതെ സാധാരണ ടൈപ്പ് മാനിപ്പുലേഷനുകൾ നടത്തുന്നതിന് സംക്ഷിപ്തവും വ്യക്തവുമായ ഒരു മാർഗ്ഗം നൽകുന്നു. യൂട്ടിലിറ്റി ടൈപ്പുകൾ ഉപയോഗിക്കുന്നത് ബോയിലർപ്ലേറ്റ് കോഡ് ഗണ്യമായി കുറയ്ക്കുകയും നിങ്ങളുടെ ടൈപ്പ് നിർവചനങ്ങൾ കൂടുതൽ വ്യക്തവും മനസ്സിലാക്കാൻ എളുപ്പമുള്ളതുമാക്കുകയും ചെയ്യും.

ഇവയെ മൂല്യങ്ങളിൽ (values) പ്രവർത്തിക്കുന്നതിന് പകരം ടൈപ്പുകളിൽ പ്രവർത്തിക്കുന്ന ഫംഗ്ഷനുകളായി ചിന്തിക്കുക. അവ ഒരു ടൈപ്പ് ഇൻപുട്ടായി എടുക്കുകയും പരിഷ്കരിച്ച ഒരു ടൈപ്പ് ഔട്ട്പുട്ടായി നൽകുകയും ചെയ്യുന്നു. ഇത് കുറഞ്ഞ കോഡ് ഉപയോഗിച്ച് സങ്കീർണ്ണമായ ടൈപ്പ് ബന്ധങ്ങളും പരിവർത്തനങ്ങളും സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

എന്തുകൊണ്ട് യൂട്ടിലിറ്റി ടൈപ്പുകൾ ഉപയോഗിക്കണം?

നിങ്ങളുടെ ടൈപ്പ്സ്ക്രിപ്റ്റ് പ്രോജക്റ്റുകളിൽ യൂട്ടിലിറ്റി ടൈപ്പുകൾ ഉൾപ്പെടുത്തുന്നതിന് നിരവധി ശക്തമായ കാരണങ്ങളുണ്ട്:

അവശ്യമായ ടൈപ്പ്സ്ക്രിപ്റ്റ് യൂട്ടിലിറ്റി ടൈപ്പുകൾ

ടൈപ്പ്സ്ക്രിപ്റ്റിലെ ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്നതും പ്രയോജനകരവുമായ ചില യൂട്ടിലിറ്റി ടൈപ്പുകൾ നമുക്ക് പരിചയപ്പെടാം. അവയുടെ ഉദ്ദേശ്യം, സിന്റാക്സ്, അവയുടെ ഉപയോഗം വ്യക്തമാക്കുന്നതിനുള്ള പ്രായോഗിക ഉദാഹരണങ്ങൾ എന്നിവ ഞങ്ങൾ ഇവിടെ ഉൾപ്പെടുത്തുന്നു.

1. Partial<T>

Partial<T> യൂട്ടിലിറ്റി ടൈപ്പ്, T എന്ന ടൈപ്പിലെ എല്ലാ പ്രോപ്പർട്ടികളെയും ഓപ്ഷണൽ ആക്കുന്നു. നിലവിലുള്ള ഒരു ടൈപ്പിന്റെ ചിലതോ എല്ലാമോ പ്രോപ്പർട്ടികളുള്ള ഒരു പുതിയ ടൈപ്പ് സൃഷ്ടിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്, എന്നാൽ അവയെല്ലാം നിർബന്ധമാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ല.

സിന്റാക്സ്:

type Partial<T> = { [P in keyof T]?: T[P]; };

ഉദാഹരണം:

interface User {
 id: number;
 name: string;
 email: string;
}

type OptionalUser = Partial<User>; // എല്ലാ പ്രോപ്പർട്ടികളും ഇപ്പോൾ ഓപ്ഷണൽ ആണ്

const partialUser: OptionalUser = {
 name: "Alice", // name പ്രോപ്പർട്ടി മാത്രം നൽകുന്നു
};

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

2. Required<T>

Required<T> യൂട്ടിലിറ്റി ടൈപ്പ്, T എന്ന ടൈപ്പിലെ എല്ലാ പ്രോപ്പർട്ടികളെയും നിർബന്ധമാക്കുന്നു. ഇത് Partial<T> യുടെ വിപരീതമാണ്. ഓപ്ഷണൽ പ്രോപ്പർട്ടികളുള്ള ഒരു ടൈപ്പ് നിങ്ങളുടെ പക്കലുണ്ടെങ്കിൽ, എല്ലാ പ്രോപ്പർട്ടികളും ഉണ്ടെന്ന് ഉറപ്പാക്കാൻ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

type Required<T> = { [P in keyof T]-?: T[P]; };

ഉദാഹരണം:

interface Config {
 apiKey?: string;
 apiUrl?: string;
}

type CompleteConfig = Required<Config>; // എല്ലാ പ്രോപ്പർട്ടികളും ഇപ്പോൾ നിർബന്ധമാണ്

const config: CompleteConfig = {
 apiKey: "your-api-key",
 apiUrl: "https://example.com/api",
};

ഉപയോഗം: ഒരു ആപ്ലിക്കേഷൻ ആരംഭിക്കുന്നതിന് മുമ്പ് എല്ലാ കോൺഫിഗറേഷൻ ക്രമീകരണങ്ങളും നൽകിയിട്ടുണ്ടെന്ന് ഉറപ്പാക്കാൻ. വിട്ടുപോയതോ നിർവചിക്കാത്തതോ ആയ ക്രമീകരണങ്ങൾ മൂലമുണ്ടാകുന്ന റൺടൈം പിശകുകൾ തടയാൻ ഇത് സഹായിക്കും.

3. Readonly<T>

Readonly<T> യൂട്ടിലിറ്റി ടൈപ്പ്, T എന്ന ടൈപ്പിലെ എല്ലാ പ്രോപ്പർട്ടികളെയും റീഡ്ഓൺലി (മാറ്റം വരുത്താൻ കഴിയാത്തവ) ആക്കുന്നു. ഒരു ഒബ്ജക്റ്റ് ഉണ്ടാക്കിയ ശേഷം അതിന്റെ പ്രോപ്പർട്ടികളിൽ ആകസ്മികമായി മാറ്റം വരുത്തുന്നത് ഇത് തടയുന്നു. ഇത് ഇമ്മ്യൂട്ടബിലിറ്റി പ്രോത്സാഹിപ്പിക്കുകയും നിങ്ങളുടെ കോഡിന്റെ പ്രവചനാത്മകത മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു.

സിന്റാക്സ്:

type Readonly<T> = { readonly [P in keyof T]: T[P]; };

ഉദാഹരണം:

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

type ImmutableProduct = Readonly<Product>; // എല്ലാ പ്രോപ്പർട്ടികളും ഇപ്പോൾ റീഡ്ഓൺലി ആണ്

const product: ImmutableProduct = {
 id: 123,
 name: "Example Product",
 price: 25.99,
};

// product.price = 29.99; // Error: 'price'-ലേക്ക് അസൈൻ ചെയ്യാൻ കഴിയില്ല, കാരണം അത് ഒരു റീഡ്-ഓൺലി പ്രോപ്പർട്ടിയാണ്.

ഉപയോഗം: കോൺഫിഗറേഷൻ ഒബ്ജക്റ്റുകൾ അല്ലെങ്കിൽ ഡാറ്റാ ട്രാൻസ്ഫർ ഒബ്ജക്റ്റുകൾ (DTOs) പോലുള്ള ഇമ്മ്യൂട്ടബിൾ ഡാറ്റാ ഘടനകൾ നിർമ്മിക്കുന്നതിന്, ഇവ ഉണ്ടാക്കിയ ശേഷം മാറ്റം വരുത്താൻ പാടില്ലാത്തവയാണ്. ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് മാതൃകകളിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

4. Pick<T, K extends keyof T>

Pick<T, K extends keyof T> യൂട്ടിലിറ്റി ടൈപ്പ്, T എന്ന ടൈപ്പിൽ നിന്ന് K എന്ന ഒരു കൂട്ടം പ്രോപ്പർട്ടികൾ തിരഞ്ഞെടുത്ത് ഒരു പുതിയ ടൈപ്പ് ഉണ്ടാക്കുന്നു. നിലവിലുള്ള ഒരു ടൈപ്പിന്റെ പ്രോപ്പർട്ടികളിൽ ഒരു ഉപവിഭാഗം മാത്രം ആവശ്യമുള്ളപ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

type Pick<T, K extends keyof T> = { [P in K]: T[P]; };

ഉദാഹരണം:

interface Employee {
 id: number;
 name: string;
 department: string;
salary: number;
}

type EmployeeNameAndDepartment = Pick<Employee, "name" | "department">; // പേരും ഡിപ്പാർട്ട്‌മെന്റും മാത്രം തിരഞ്ഞെടുക്കുക

const employeeInfo: EmployeeNameAndDepartment = {
 name: "Bob",
 department: "Engineering",
};

ഉപയോഗം: ഒരു പ്രത്യേക പ്രവർത്തനത്തിന് ആവശ്യമായ ഡാറ്റ മാത്രം അടങ്ങുന്ന സ്പെഷ്യലൈസ്ഡ് ഡാറ്റാ ട്രാൻസ്ഫർ ഒബ്ജക്റ്റുകൾ (DTOs) നിർമ്മിക്കുന്നതിന്. ഇത് പ്രകടനം മെച്ചപ്പെടുത്തുകയും നെറ്റ്‌വർക്കിലൂടെ കൈമാറ്റം ചെയ്യപ്പെടുന്ന ഡാറ്റയുടെ അളവ് കുറയ്ക്കുകയും ചെയ്യും. ശമ്പളം പോലുള്ള സെൻസിറ്റീവ് വിവരങ്ങൾ ഒഴിവാക്കി ഉപയോക്തൃ വിവരങ്ങൾ ക്ലയന്റിലേക്ക് അയക്കുന്നത് സങ്കൽപ്പിക്കുക. `id`, `name` എന്നിവ മാത്രം അയക്കാൻ നിങ്ങൾക്ക് Pick ഉപയോഗിക്കാം.

5. Omit<T, K extends keyof any>

Omit<T, K extends keyof any> യൂട്ടിലിറ്റി ടൈപ്പ്, T എന്ന ടൈപ്പിൽ നിന്ന് K എന്ന ഒരു കൂട്ടം പ്രോപ്പർട്ടികൾ ഒഴിവാക്കി ഒരു പുതിയ ടൈപ്പ് ഉണ്ടാക്കുന്നു. ഇത് Pick<T, K extends keyof T> ന്റെ വിപരീതമാണ്, നിലവിലുള്ള ഒരു ടൈപ്പിൽ നിന്ന് ചില പ്രോപ്പർട്ടികൾ ഒഴിവാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

ഉദാഹരണം:

interface Event {
 id: number;
 title: string;
description: string;
 date: Date;
 location: string;
}

type EventSummary = Omit<Event, "description" | "location">; // description, location എന്നിവ ഒഴിവാക്കുക

const eventPreview: EventSummary = {
 id: 1,
 title: "Conference",
 date: new Date(),
};

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

6. Exclude<T, U>

Exclude<T, U> യൂട്ടിലിറ്റി ടൈപ്പ്, T എന്ന ടൈപ്പിൽ നിന്ന് U-വിലേക്ക് അസൈൻ ചെയ്യാൻ കഴിയുന്ന എല്ലാ ടൈപ്പുകളെയും ഒഴിവാക്കി ഒരു പുതിയ ടൈപ്പ് ഉണ്ടാക്കുന്നു. ഒരു യൂണിയൻ ടൈപ്പിൽ നിന്ന് ചില ടൈപ്പുകൾ നീക്കം ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

type Exclude<T, U> = T extends U ? never : T;

ഉദാഹരണം:

type AllowedFileTypes = "image" | "video" | "audio" | "document";
type MediaFileTypes = "image" | "video" | "audio";

type DocumentFileTypes = Exclude<AllowedFileTypes, MediaFileTypes>; // "document"

const fileType: DocumentFileTypes = "document";

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

7. Extract<T, U>

Extract<T, U> യൂട്ടിലിറ്റി ടൈപ്പ്, T എന്ന ടൈപ്പിൽ നിന്ന് U-വിലേക്ക് അസൈൻ ചെയ്യാൻ കഴിയുന്ന എല്ലാ ടൈപ്പുകളെയും എക്സ്ട്രാക്റ്റ് ചെയ്ത് ഒരു പുതിയ ടൈപ്പ് ഉണ്ടാക്കുന്നു. ഇത് Exclude<T, U> ന്റെ വിപരീതമാണ്, ഒരു യൂണിയൻ ടൈപ്പിൽ നിന്ന് പ്രത്യേക ടൈപ്പുകൾ തിരഞ്ഞെടുക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

type Extract<T, U> = T extends U ? T : never;

ഉദാഹരണം:

type InputTypes = string | number | boolean | null | undefined;
type PrimitiveTypes = string | number | boolean;

type NonNullablePrimitives = Extract<InputTypes, PrimitiveTypes>; // string | number | boolean

const value: NonNullablePrimitives = "hello";

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

8. NonNullable<T>

NonNullable<T> യൂട്ടിലിറ്റി ടൈപ്പ്, T എന്ന ടൈപ്പിൽ നിന്ന് null, undefined എന്നിവ ഒഴിവാക്കി ഒരു പുതിയ ടൈപ്പ് ഉണ്ടാക്കുന്നു. ഒരു ടൈപ്പ് null അല്ലെങ്കിൽ undefined ആകാൻ പാടില്ലെന്ന് ഉറപ്പാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

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

ഉദാഹരണം:

type MaybeString = string | null | undefined;

type DefinitelyString = NonNullable<MaybeString>; // string

const message: DefinitelyString = "Hello, world!";

ഉപയോഗം: ഒരു മൂല്യത്തിൽ ഒരു ഓപ്പറേഷൻ നടത്തുന്നതിന് മുമ്പ് അത് null അല്ലെങ്കിൽ undefined അല്ലെന്ന് ഉറപ്പാക്കാൻ. അപ്രതീക്ഷിത null അല്ലെങ്കിൽ undefined മൂല്യങ്ങൾ മൂലമുണ്ടാകുന്ന റൺടൈം പിശകുകൾ തടയാൻ ഇത് സഹായിക്കും. ഒരു ഉപയോക്താവിന്റെ വിലാസം പ്രോസസ്സ് ചെയ്യേണ്ട ഒരു സാഹചര്യം പരിഗണിക്കുക, ഏതെങ്കിലും പ്രവർത്തനത്തിന് മുമ്പ് വിലാസം null അല്ലാത്തത് നിർണായകമാണ്.

9. ReturnType<T extends (...args: any) => any>

ReturnType<T extends (...args: any) => any> യൂട്ടിലിറ്റി ടൈപ്പ്, ഒരു ഫംഗ്ഷൻ ടൈപ്പ് T-യുടെ റിട്ടേൺ ടൈപ്പ് എക്സ്ട്രാക്റ്റ് ചെയ്യുന്നു. ഒരു ഫംഗ്ഷൻ നൽകുന്ന മൂല്യത്തിന്റെ ടൈപ്പ് അറിയാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

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

ഉദാഹരണം:

function fetchData(url: string): Promise<{ data: any }> {
 return fetch(url).then(response => response.json());
}

type FetchDataReturnType = ReturnType<typeof fetchData>; // Promise<{ data: any }>

async function processData(data: FetchDataReturnType) {
 // ...
}

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

10. Parameters<T extends (...args: any) => any>

Parameters<T extends (...args: any) => any> യൂട്ടിലിറ്റി ടൈപ്പ്, ഒരു ഫംഗ്ഷൻ ടൈപ്പ് T-യുടെ പാരാമീറ്റർ ടൈപ്പുകൾ ഒരു ടപ്പിളായി (tuple) എക്സ്ട്രാക്റ്റ് ചെയ്യുന്നു. ഒരു ഫംഗ്ഷൻ സ്വീകരിക്കുന്ന ആർഗ്യുമെന്റുകളുടെ ടൈപ്പുകൾ അറിയാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

ഉദാഹരണം:

function createUser(name: string, age: number, email: string): void {
 // ...
}

type CreateUserParams = Parameters<typeof createUser>; // [string, number, string]

function logUser(...args: CreateUserParams) {
 console.log("Creating user with:", args);
}

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

11. ConstructorParameters<T extends abstract new (...args: any) => any>

ConstructorParameters<T extends abstract new (...args: any) => any> യൂട്ടിലിറ്റി ടൈപ്പ്, ഒരു കൺസ്ട്രക്റ്റർ ഫംഗ്ഷൻ ടൈപ്പ് T-യുടെ പാരാമീറ്റർ ടൈപ്പുകൾ ഒരു ടപ്പിളായി എക്സ്ട്രാക്റ്റ് ചെയ്യുന്നു. ഒരു കൺസ്ട്രക്റ്റർ സ്വീകരിക്കുന്ന ആർഗ്യുമെന്റുകളുടെ ടൈപ്പുകൾ അറിയാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;

ഉദാഹരണം:

class Logger {
 constructor(public prefix: string, public enabled: boolean) {}
 log(message: string) {
 if (this.enabled) {
 console.log(`${this.prefix}: ${message}`);
 }
 }
}

type LoggerConstructorParams = ConstructorParameters<typeof Logger>; // [string, boolean]

function createLogger(...args: LoggerConstructorParams) {
 return new Logger(...args);
}

ഉപയോഗം: Parameters പോലെ തന്നെ, പക്ഷേ കൺസ്ട്രക്റ്റർ ഫംഗ്ഷനുകൾക്ക് വേണ്ടി മാത്രം. വ്യത്യസ്ത കൺസ്ട്രക്റ്റർ സിഗ്നേച്ചറുകളുള്ള ക്ലാസുകളെ ഡൈനാമിക്കായി ഇൻസ്റ്റാൻഷ്യേറ്റ് ചെയ്യേണ്ട ഫാക്ടറികൾ അല്ലെങ്കിൽ ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ സിസ്റ്റങ്ങൾ നിർമ്മിക്കുമ്പോൾ ഇത് സഹായിക്കുന്നു.

12. InstanceType<T extends abstract new (...args: any) => any>

InstanceType<T extends abstract new (...args: any) => any> യൂട്ടിലിറ്റി ടൈപ്പ്, ഒരു കൺസ്ട്രക്റ്റർ ഫംഗ്ഷൻ ടൈപ്പ് T-യുടെ ഇൻസ്റ്റൻസ് ടൈപ്പ് എക്സ്ട്രാക്റ്റ് ചെയ്യുന്നു. ഒരു കൺസ്ട്രക്റ്റർ നിർമ്മിക്കുന്ന ഒബ്ജക്റ്റിന്റെ ടൈപ്പ് അറിയാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

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

ഉദാഹരണം:

class Greeter {
 greeting: string;
 constructor(message: string) {
 this.greeting = message;
 }
 greet() {
 return "Hello, " + this.greeting;
 }
}

type GreeterInstance = InstanceType<typeof Greeter>; // Greeter

const myGreeter: GreeterInstance = new Greeter("World");
console.log(myGreeter.greet());

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

13. Record<K extends keyof any, T>

Record<K extends keyof any, T> യൂട്ടിലിറ്റി ടൈപ്പ്, പ്രോപ്പർട്ടി കീകൾ K-യും പ്രോപ്പർട്ടി മൂല്യങ്ങൾ T-യും ആയ ഒരു ഒബ്ജക്റ്റ് ടൈപ്പ് നിർമ്മിക്കുന്നു. നിങ്ങൾക്ക് കീകൾ മുൻകൂട്ടി അറിയാമെങ്കിൽ ഡിക്ഷണറി പോലുള്ള ടൈപ്പുകൾ നിർമ്മിക്കാൻ ഇത് ഉപയോഗപ്രദമാണ്.

സിന്റാക്സ്:

type Record<K extends keyof any, T> = { [P in K]: T; };

ഉദാഹരണം:

type CountryCode = "US" | "CA" | "GB" | "DE";

type CurrencyMap = Record<CountryCode, string>; // { US: string; CA: string; GB: string; DE: string; }

const currencies: CurrencyMap = {
 US: "USD",
 CA: "CAD",
 GB: "GBP",
 DE: "EUR",
};

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

കസ്റ്റം യൂട്ടിലിറ്റി ടൈപ്പുകൾ

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

ഉദാഹരണം:

// ഒരു ഒബ്ജക്റ്റിന്റെ ഒരു പ്രത്യേക ടൈപ്പ് ഉള്ള കീകൾ ലഭിക്കുന്നതിനുള്ള യൂട്ടിലിറ്റി ടൈപ്പ്
type KeysOfType<T, U> = { [K in keyof T]: T[K] extends U ? K : never }[keyof T];

interface Person {
 name: string;
 age: number;
 address: string;
 phoneNumber: number;
}

type StringKeys = KeysOfType<Person, string>; // "name" | "address"

യൂട്ടിലിറ്റി ടൈപ്പുകൾ ഉപയോഗിക്കുന്നതിനുള്ള മികച്ച രീതികൾ

ഉപസംഹാരം

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

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