டைப்ஸ்கிரிப்ட் யூட்டிலிட்டி வகைகள்: உள்ளமைக்கப்பட்ட வகை கையாளுதல் கருவிகள்

டைப்ஸ்கிரிப்ட் என்பது ஜாவாஸ்கிரிப்டிற்கு ஸ்டேடிக் டைப்பிங்கைக் கொண்டுவரும் ஒரு சக்திவாய்ந்த மொழியாகும். அதன் முக்கிய அம்சங்களில் ஒன்று வகைகளைக் கையாளும் திறன், இது டெவலப்பர்களை மிகவும் வலுவான மற்றும் பராமரிக்கக்கூடிய குறியீட்டை உருவாக்க அனுமதிக்கிறது. டைப்ஸ்கிரிப்ட் பொதுவான வகை மாற்றங்களை எளிதாக்கும் உள்ளமைக்கப்பட்ட யூட்டிலிட்டி வகைகளின் தொகுப்பை வழங்குகிறது. இந்த யூட்டிலிட்டி வகைகள் வகை பாதுகாப்பை மேம்படுத்துவதற்கும், குறியீட்டின் மறுபயன்பாட்டை மேம்படுத்துவதற்கும், மற்றும் உங்கள் மேம்பாட்டுப் பணிப்பாய்வுகளை சீரமைப்பதற்கும் விலைமதிப்பற்ற கருவிகளாகும். இந்த விரிவான வழிகாட்டி மிகவும் அவசியமான டைப்ஸ்கிரிப்ட் யூட்டிலிட்டி வகைகளை ஆராய்கிறது, அவற்றை நீங்கள் முழுமையாகக் கற்றுக்கொள்ள உதவும் நடைமுறை எடுத்துக்காட்டுகள் மற்றும் செயல்படுத்தக்கூடிய நுண்ணறிவுகளை வழங்குகிறது.

டைப்ஸ்கிரிப்ட் யூட்டிலிட்டி வகைகள் என்றால் என்ன?

யூட்டிலிட்டி வகைகள் என்பவை ஏற்கனவே உள்ள வகைகளை புதிய வகைகளாக மாற்றும் முன்வரையறுக்கப்பட்ட வகை ஆபரேட்டர்கள் ஆகும். அவை டைப்ஸ்கிரிப்ட் மொழியில் உள்ளமைக்கப்பட்டுள்ளன மற்றும் பொதுவான வகை கையாளுதல்களைச் செய்ய ஒரு சுருக்கமான மற்றும் அறிவிப்பு வழியை வழங்குகின்றன. யூட்டிலிட்டி வகைகளைப் பயன்படுத்துவது பாய்லர்பிளேட் குறியீட்டைக் கணிசமாகக் குறைத்து, உங்கள் வகை வரையறைகளை மேலும் வெளிப்படையானதாகவும் புரிந்துகொள்ள எளிதாகவும் மாற்றும்.

அவற்றை மதிப்புகளுக்குப் பதிலாக வகைகளில் செயல்படும் செயல்பாடுகளாக நினைத்துப் பாருங்கள். அவை ஒரு வகையை உள்ளீடாக எடுத்து, மாற்றியமைக்கப்பட்ட வகையை வெளியீடாகத் தருகின்றன. இது குறைந்தபட்ச குறியீட்டைக் கொண்டு சிக்கலான வகை உறவுகளையும் மாற்றங்களையும் உருவாக்க உங்களை அனுமதிக்கிறது.

யூட்டிலிட்டி வகைகளை ஏன் பயன்படுத்த வேண்டும்?

உங்கள் டைப்ஸ்கிரிப்ட் திட்டங்களில் யூட்டிலிட்டி வகைகளை இணைக்க பல வலுவான காரணங்கள் உள்ளன:

• அதிகரிக்கப்பட்ட வகை பாதுகாப்பு: யூட்டிலிட்டி வகைகள் கடுமையான வகை கட்டுப்பாடுகளைச் செயல்படுத்த உதவுகின்றன, இதனால் இயக்க நேரப் பிழைகளின் வாய்ப்பு குறைந்து உங்கள் குறியீட்டின் ஒட்டுமொத்த நம்பகத்தன்மை மேம்படுகிறது.
• மேம்படுத்தப்பட்ட குறியீடு மறுபயன்பாடு: யூட்டிலிட்டி வகைகளைப் பயன்படுத்துவதன் மூலம், பல்வேறு வகையான வகைகளுடன் செயல்படும் பொதுவான கூறுகள் மற்றும் செயல்பாடுகளை உருவாக்கலாம், இது குறியீட்டின் மறுபயன்பாட்டை ஊக்குவித்து தேவையற்றவற்றை குறைக்கிறது.
• குறைக்கப்பட்ட பாய்லர்பிளேட்: யூட்டிலிட்டி வகைகள் பொதுவான வகை மாற்றங்களைச் செய்ய ஒரு சுருக்கமான மற்றும் அறிவிப்பு வழியை வழங்குகின்றன, இதனால் நீங்கள் எழுத வேண்டிய பாய்லர்பிளேட் குறியீட்டின் அளவு குறைகிறது.
• மேம்படுத்தப்பட்ட வாசிப்புத்திறன்: யூட்டிலிட்டி வகைகள் உங்கள் வகை வரையறைகளை மேலும் வெளிப்படையானதாகவும் புரிந்துகொள்ள எளிதாகவும் ஆக்குகின்றன, இது உங்கள் குறியீட்டின் வாசிப்புத்திறன் மற்றும் பராமரிப்புத்தன்மையை மேம்படுத்துகிறது.

அத்தியாவசிய டைப்ஸ்கிரிப்ட் யூட்டிலிட்டி வகைகள்

டைப்ஸ்கிரிப்டில் மிகவும் பொதுவாகப் பயன்படுத்தப்படும் மற்றும் பயனுள்ள சில யூட்டிலிட்டி வகைகளை ஆராய்வோம். அவற்றின் நோக்கம், தொடரியல் மற்றும் அவற்றின் பயன்பாட்டை விளக்குவதற்கான நடைமுறை எடுத்துக்காட்டுகளை நாங்கள் உள்ளடக்குவோம்.

1. Partial<T>

Partial<T> யூட்டிலிட்டி வகை, T வகையின் அனைத்து பண்புகளையும் விருப்பத்திற்குரியதாக (optional) மாற்றுகிறது. இது ஒரு புதிய வகையை உருவாக்க விரும்பும் போது பயனுள்ளதாக இருக்கும், இது ஏற்கனவே உள்ள வகையின் சில அல்லது அனைத்து பண்புகளையும் கொண்டுள்ளது, ஆனால் அவை அனைத்தும் இருக்க வேண்டும் என்று நீங்கள் கட்டாயப்படுத்த விரும்பவில்லை.

தொடரியல்:

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", // பெயர் பண்பை மட்டும் வழங்குகிறோம்
};

பயன்பாட்டு நிலை: ஒரு பொருளை சில பண்புகளுடன் மட்டும் புதுப்பித்தல். எடுத்துக்காட்டாக, ஒரு பயனர் சுயவிவர புதுப்பிப்பு படிவத்தை கற்பனை செய்து பாருங்கள். பயனர்கள் ஒரே நேரத்தில் ஒவ்வொரு புலத்தையும் புதுப்பிக்க வேண்டும் என்று நீங்கள் கட்டாயப்படுத்த விரும்பவில்லை.

2. Required<T>

Required<T> யூட்டிலிட்டி வகை, T வகையின் அனைத்து பண்புகளையும் அவசியமானதாக (required) மாற்றுகிறது. இது 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 வகையின் அனைத்து பண்புகளையும் படிக்க மட்டுமேயானதாக (readonly) மாற்றுகிறது. இது ஒரு பொருள் உருவாக்கப்பட்ட பிறகு அதன் பண்புகளை தற்செயலாக மாற்றுவதைத் தடுக்கிறது. இது மாற்றமுடியாத தன்மையை (immutability) ஊக்குவிக்கிறது மற்றும் உங்கள் குறியீட்டின் கணிக்கக்கூடிய தன்மையை மேம்படுத்துகிறது.

தொடரியல்:

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: Cannot assign to 'price' because it is a read-only property.

பயன்பாட்டு நிலை: உள்ளமைவுப் பொருள்கள் அல்லது தரவு பரிமாற்றப் பொருள்கள் (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">; // விளக்கம் மற்றும் இருப்பிடத்தைத் தவிர்க்கவும்

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 இன் அளவுரு வகைகளை ஒரு டப்பிளாக (tuple) பிரித்தெடுக்கிறது. ஒரு கன்ஸ்ட்ரக்டர் ஏற்கும் ஆர்க்யுமென்ட்களின் வகைகளை அறிய விரும்பும்போது இது பயனுள்ளதாக இருக்கும்.

தொடரியல்:

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 போன்றது, ஆனால் குறிப்பாக கன்ஸ்ட்ரக்டர் செயல்பாடுகளுக்கு. வெவ்வேறு கன்ஸ்ட்ரக்டர் கையொப்பங்களைக் கொண்ட கிளாஸ்களை மாறும் வகையில் நீங்கள் இன்ஸ்டன்ஷியேட் செய்ய வேண்டியிருக்கும் போது ஃபேக்டரிகள் அல்லது சார்பு ஊசி அமைப்புகளை (dependency injection systems) உருவாக்கும்போது இது உதவுகிறது.

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());

பயன்பாட்டு நிலை: ஒரு கன்ஸ்ட்ரக்டரால் உருவாக்கப்பட்ட பொருளின் வகையைத் தீர்மானித்தல், இது பரம்பரை (inheritance) அல்லது பன்முகத்தன்மையுடன் (polymorphism) வேலை செய்யும்போது பயனுள்ளதாக இருக்கும். இது ஒரு கிளாஸின் இன்ஸ்டன்ஸைக் குறிக்க வகை-பாதுகாப்பான வழியை வழங்குகிறது.

13. Record<K extends keyof any, T>

Record<K extends keyof any, T> யூட்டிலிட்டி வகை, ஒரு பொருள் வகையை உருவாக்குகிறது, அதன் பண்பு விசைகள் (keys) K ஆகவும், அதன் பண்பு மதிப்புகள் (values) 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"

யூட்டிலிட்டி வகைகளைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

• விளக்கமான பெயர்களைப் பயன்படுத்துங்கள்: உங்கள் யூட்டிலிட்டி வகைகளுக்கு அவற்றின் நோக்கத்தைத் தெளிவாகக் குறிக்கும் அர்த்தமுள்ள பெயர்களைக் கொடுங்கள். இது உங்கள் குறியீட்டின் வாசிப்புத்திறன் மற்றும் பராமரிப்புத்தன்மையை மேம்படுத்துகிறது.
• உங்கள் யூட்டிலிட்டி வகைகளை ஆவணப்படுத்துங்கள்: உங்கள் யூட்டிலிட்டி வகைகள் என்ன செய்கின்றன, அவற்றை எப்படிப் பயன்படுத்த வேண்டும் என்பதை விளக்க கருத்துகளைச் சேர்க்கவும். இது மற்ற டெவலப்பர்கள் உங்கள் குறியீட்டைப் புரிந்துகொண்டு அதைச் சரியாகப் பயன்படுத்த உதவுகிறது.
• அதை எளிமையாக வைத்திருங்கள்: புரிந்துகொள்ள கடினமாக இருக்கும் அதிகப்படியான சிக்கலான யூட்டிலிட்டி வகைகளை உருவாக்குவதைத் தவிர்க்கவும். சிக்கலான மாற்றங்களை சிறிய, மேலும் நிர்வகிக்கக்கூடிய யூட்டிலிட்டி வகைகளாக உடைக்கவும்.
• உங்கள் யூட்டிலிட்டி வகைகளைச் சோதிக்கவும்: உங்கள் யூட்டிலிட்டி வகைகள் சரியாக வேலை செய்கின்றன என்பதை உறுதிப்படுத்த யூனிட் சோதனைகளை எழுதுங்கள். இது எதிர்பாராத பிழைகளைத் தடுக்க உதவுகிறது மற்றும் உங்கள் வகைகள் எதிர்பார்த்தபடி செயல்படுகின்றன என்பதை உறுதி செய்கிறது.
• செயல்திறனைக் கவனியுங்கள்: யூட்டிலிட்டி வகைகள் பொதுவாக குறிப்பிடத்தக்க செயல்திறன் தாக்கத்தை ஏற்படுத்தாது என்றாலும், உங்கள் வகை மாற்றங்களின் சிக்கலான தன்மை குறித்து கவனமாக இருங்கள், குறிப்பாக பெரிய திட்டங்களில்.

முடிவுரை

டைப்ஸ்கிரிப்ட் யூட்டிலிட்டி வகைகள் உங்கள் குறியீட்டின் வகை பாதுகாப்பு, மறுபயன்பாடு மற்றும் பராமரிப்புத்தன்மையை கணிசமாக மேம்படுத்தக்கூடிய சக்திவாய்ந்த கருவிகளாகும். இந்த யூட்டிலிட்டி வகைகளில் தேர்ச்சி பெறுவதன் மூலம், நீங்கள் மேலும் வலுவான மற்றும் வெளிப்படையான டைப்ஸ்கிரிப்ட் பயன்பாடுகளை எழுதலாம். இந்த வழிகாட்டி மிகவும் அவசியமான டைப்ஸ்கிரிப்ட் யூட்டிலிட்டி வகைகளை உள்ளடக்கியுள்ளது, உங்கள் திட்டங்களில் அவற்றை இணைக்க உதவும் நடைமுறை எடுத்துக்காட்டுகள் மற்றும் செயல்படுத்தக்கூடிய நுண்ணறிவுகளை வழங்குகிறது.

இந்த யூட்டிலிட்டி வகைகளுடன் பரிசோதனை செய்து, உங்கள் சொந்த குறியீட்டில் உள்ள குறிப்பிட்ட சிக்கல்களைத் தீர்க்க அவற்றை எப்படிப் பயன்படுத்தலாம் என்பதை ஆராய நினைவில் கொள்ளுங்கள். நீங்கள் அவற்றுடன் மேலும் பழக்கமாகும்போது, தூய்மையான, மேலும் பராமரிக்கக்கூடிய, மற்றும் மேலும் வகை-பாதுகாப்பான டைப்ஸ்கிரிப்ட் பயன்பாடுகளை உருவாக்க அவற்றை நீங்கள் மேலும் மேலும் பயன்படுத்துவதைக் காண்பீர்கள். நீங்கள் வலைப் பயன்பாடுகள், சர்வர்-பக்க பயன்பாடுகள் அல்லது இடையில் உள்ள எதையும் உருவாக்கினாலும், யூட்டிலிட்டி வகைகள் உங்கள் மேம்பாட்டுப் பணிப்பாய்வு மற்றும் உங்கள் குறியீட்டின் தரத்தை மேம்படுத்துவதற்கான மதிப்புமிக்க கருவிகளின் தொகுப்பை வழங்குகின்றன. இந்த உள்ளமைக்கப்பட்ட வகை கையாளுதல் கருவிகளைப் பயன்படுத்துவதன் மூலம், நீங்கள் டைப்ஸ்கிரிப்டின் முழுத் திறனையும் திறந்து, வெளிப்படையான மற்றும் வலுவான குறியீட்டை எழுதலாம்.