M

MLOG

తెలుగు

టైప్‌స్క్రిప్ట్ యొక్క యుటిలిటీ రకాలను నేర్చుకోండి: టైప్ మార్పుల కోసం శక్తివంతమైన సాధనాలు, కోడ్ పునర్వినియోగాన్ని మెరుగుపరచడం మరియు మీ అప్లికేషన్‌లలో టైప్ భద్రతను పెంచడం.

టైప్‌స్క్రిప్ట్ యుటిలిటీ రకాలు: అంతర్నిర్మిత టైప్ మానిప్యులేషన్ సాధనాలు

టైప్‌స్క్రిప్ట్ అనేది జావాస్క్రిప్ట్‌కు స్టాటిక్ టైపింగ్‌ను అందించే ఒక శక్తివంతమైన భాష. దీని ముఖ్యమైన ఫీచర్లలో ఒకటి టైప్‌లను మార్చగల సామర్థ్యం, ఇది డెవలపర్‌లకు మరింత దృఢమైన మరియు నిర్వహించదగిన కోడ్‌ను సృష్టించడానికి అనుమతిస్తుంది. టైప్‌స్క్రిప్ట్ సాధారణ టైప్ మార్పులను సులభతరం చేసే అంతర్నిర్మిత యుటిలిటీ రకాల సమితిని అందిస్తుంది. ఈ యుటిలిటీ రకాలు టైప్ భద్రతను పెంచడానికి, కోడ్ పునర్వినియోగాన్ని మెరుగుపరచడానికి మరియు మీ డెవలప్‌మెంట్ వర్క్‌ఫ్లోను క్రమబద్ధీకరించడానికి అమూల్యమైన సాధనాలు. ఈ సమగ్ర గైడ్ అత్యంత ముఖ్యమైన టైప్‌స్క్రిప్ట్ యుటిలిటీ రకాలను అన్వేషిస్తుంది, వాటిని మీరు నేర్చుకోవడంలో సహాయపడటానికి ఆచరణాత్మక ఉదాహరణలు మరియు కార్యాచరణ అంతర్దృష్టులను అందిస్తుంది.

టైప్‌స్క్రిప్ట్ యుటిలిటీ రకాలు అంటే ఏమిటి?

యుటిలిటీ రకాలు అనేవి ఇప్పటికే ఉన్న రకాలను కొత్త రకాలుగా మార్చే ముందుగా నిర్వచించబడిన టైప్ ఆపరేటర్లు. ఇవి టైప్‌స్క్రిప్ట్ భాషలో అంతర్నిర్మితంగా ఉంటాయి మరియు సాధారణ టైప్ మానిప్యులేషన్‌లను చేయడానికి సంక్షిప్తమైన మరియు డిక్లరేటివ్ మార్గాన్ని అందిస్తాయి. యుటిలిటీ రకాలను ఉపయోగించడం వల్ల బాయిలర్‌ప్లేట్ కోడ్ గణనీయంగా తగ్గుతుంది మరియు మీ టైప్ నిర్వచనాలు మరింత వ్యక్తీకరణతో మరియు సులభంగా అర్థమయ్యేలా ఉంటాయి.

వాటిని విలువలపై కాకుండా రకాలపై పనిచేసే ఫంక్షన్‌లుగా భావించండి. అవి ఇన్‌పుట్‌గా ఒక రకాన్ని తీసుకుని, సవరించిన రకాన్ని అవుట్‌పుట్‌గా అందిస్తాయి. ఇది తక్కువ కోడ్‌తో సంక్లిష్టమైన టైప్ సంబంధాలను మరియు మార్పులను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది.

యుటిలిటీ రకాలను ఎందుకు ఉపయోగించాలి?

మీ టైప్‌స్క్రిప్ట్ ప్రాజెక్ట్‌లలో యుటిలిటీ రకాలను చేర్చడానికి అనేక బలమైన కారణాలు ఉన్నాయి:

అవసరమైన టైప్‌స్క్రిప్ట్ యుటిలిటీ రకాలు

టైప్‌స్క్రిప్ట్‌లో అత్యంత సాధారణంగా ఉపయోగించే మరియు ప్రయోజనకరమైన కొన్ని యుటిలిటీ రకాలను అన్వేషిద్దాం. వాటి ఉద్దేశ్యం, సింటాక్స్ మరియు వాటి వినియోగాన్ని వివరించడానికి ఆచరణాత్మక ఉదాహరణలను అందిస్తాము.

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; // లోపం: 'price'కు విలువ కేటాయించలేము ఎందుకంటే ఇది రీడ్-ఓన్లీ ప్రాపర్టీ.

వినియోగ సందర్భం: కాన్ఫిగరేషన్ ఆబ్జెక్ట్‌లు లేదా డేటా ట్రాన్స్‌ఫర్ ఆబ్జెక్ట్‌లు (DTOలు) వంటి మార్పుచేయలేని డేటా స్ట్రక్చర్‌లను సృష్టించడం, వాటిని సృష్టించిన తర్వాత మార్చకూడదు. ఇది ముఖ్యంగా ఫంక్షనల్ ప్రోగ్రామింగ్ పారాడైమ్‌లలో ఉపయోగపడుతుంది.

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",
};

వినియోగ సందర్భం: ఒక నిర్దిష్ట ఆపరేషన్ కోసం అవసరమైన డేటాను మాత్రమే కలిగి ఉండే ప్రత్యేకమైన డేటా ట్రాన్స్‌ఫర్ ఆబ్జెక్ట్‌లు (DTOలు) సృష్టించడం. ఇది పనితీరును మెరుగుపరుస్తుంది మరియు నెట్‌వర్క్‌లో ప్రసారం చేయబడే డేటా పరిమాణాన్ని తగ్గిస్తుంది. జీతం వంటి సున్నితమైన సమాచారాన్ని మినహాయించి, క్లయింట్‌కు యూజర్ వివరాలను పంపడం ఊహించుకోండి. మీరు కేవలం `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 కాదని నిర్ధారించడం. ఇది ఊహించని నల్ లేదా అన్‌డిఫైన్డ్ విలువల వల్ల కలిగే రన్‌టైమ్ లోపాలను నివారించడంలో సహాయపడుతుంది. మీరు ఒక యూజర్ యొక్క చిరునామాను ప్రాసెస్ చేయవలసిన సందర్భంలో, మరియు ఏ ఆపరేషన్ ముందు అయినా చిరునామా నల్ కాకుండా ఉండటం ముఖ్యం అని పరిగణించండి.

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"

యుటిలిటీ రకాలను ఉపయోగించడానికి ఉత్తమ పద్ధతులు

ముగింపు

టైప్‌స్క్రిప్ట్ యుటిలిటీ రకాలు మీ కోడ్ యొక్క టైప్ భద్రత, పునర్వినియోగం మరియు నిర్వహణను గణనీయంగా మెరుగుపరచగల శక్తివంతమైన సాధనాలు. ఈ యుటిలిటీ రకాలను నేర్చుకోవడం ద్వారా, మీరు మరింత దృఢమైన మరియు వ్యక్తీకరణతో కూడిన టైప్‌స్క్రిప్ట్ అప్లికేషన్‌లను వ్రాయవచ్చు. ఈ గైడ్ అత్యంత ముఖ్యమైన టైప్‌స్క్రిప్ట్ యుటిలిటీ రకాలను కవర్ చేసింది, వాటిని మీ ప్రాజెక్ట్‌లలో చేర్చడంలో మీకు సహాయపడటానికి ఆచరణాత్మక ఉదాహరణలు మరియు కార్యాచరణ అంతర్దృష్టులను అందించింది.

ఈ యుటిలిటీ రకాలతో ప్రయోగాలు చేయడం మరియు మీ స్వంత కోడ్‌లోని నిర్దిష్ట సమస్యలను పరిష్కరించడానికి వాటిని ఎలా ఉపయోగించవచ్చో అన్వేషించడం గుర్తుంచుకోండి. మీరు వాటితో మరింత సుపరిచితులైన కొద్దీ, మీరు శుభ్రమైన, మరింత నిర్వహించదగిన, మరియు మరింత టైప్-సేఫ్ టైప్‌స్క్రిప్ట్ అప్లికేషన్‌లను సృష్టించడానికి వాటిని ఎక్కువగా ఉపయోగిస్తారు. మీరు వెబ్ అప్లికేషన్‌లు, సర్వర్-సైడ్ అప్లికేషన్‌లు, లేదా మధ్యలో ఏదైనా నిర్మిస్తున్నా, యుటిలిటీ రకాలు మీ డెవలప్‌మెంట్ వర్క్‌ఫ్లో మరియు మీ కోడ్ నాణ్యతను మెరుగుపరచడానికి విలువైన సాధనాల సమితిని అందిస్తాయి. ఈ అంతర్నిర్మిత టైప్ మానిప్యులేషన్ సాధనాలను ఉపయోగించుకోవడం ద్వారా, మీరు టైప్‌స్క్రిప్ట్ యొక్క పూర్తి సామర్థ్యాన్ని అన్‌లాక్ చేయవచ్చు మరియు వ్యక్తీకరణతో కూడిన మరియు దృఢమైన కోడ్‌ను వ్రాయవచ్చు.