M

MLOG

हिन्दी

टाइपस्क्रिप्ट के यूटिलिटी टाइप्स में महारत हासिल करें: टाइप ट्रांसफॉर्मेशन के लिए शक्तिशाली उपकरण, जो कोड पुन: प्रयोज्यता और आपके एप्लिकेशन्स में टाइप सुरक्षा को बढ़ाते हैं।

टाइपस्क्रिप्ट यूटिलिटी टाइप्स: अंतर्निहित टाइप मैनिपुलेशन टूल्स

टाइपस्क्रिप्ट एक शक्तिशाली भाषा है जो जावास्क्रिप्ट में स्टैटिक टाइपिंग लाती है। इसकी प्रमुख विशेषताओं में से एक है टाइप्स को मैनिपुलेट करने की क्षमता, जो डेवलपर्स को अधिक मजबूत और रखरखाव योग्य कोड बनाने की अनुमति देती है। टाइपस्क्रिप्ट में अंतर्निहित यूटिलिटी टाइप्स का एक सेट होता है जो सामान्य टाइप ट्रांसफॉर्मेशन को सरल बनाता है। ये यूटिलिटी टाइप्स टाइप सुरक्षा बढ़ाने, कोड पुन: प्रयोज्यता में सुधार करने और आपके डेवलपमेंट वर्कफ़्लो को सुव्यवस्थित करने के लिए अमूल्य उपकरण हैं। यह व्यापक गाइड सबसे आवश्यक टाइपस्क्रिप्ट यूटिलिटी टाइप्स की पड़ताल करता है, जिसमें आपको महारत हासिल करने में मदद करने के लिए व्यावहारिक उदाहरण और कार्रवाई योग्य अंतर्दृष्टि प्रदान की गई है।

टाइपस्क्रिप्ट यूटिलिटी टाइप्स क्या हैं?

यूटिलिटी टाइप्स पूर्वनिर्धारित टाइप ऑपरेटर्स हैं जो मौजूदा टाइप्स को नए टाइप्स में बदलते हैं। वे टाइपस्क्रिप्ट भाषा में अंतर्निहित हैं और सामान्य टाइप मैनिपुलेशन करने का एक संक्षिप्त और घोषणात्मक तरीका प्रदान करते हैं। यूटिलिटी टाइप्स का उपयोग करने से बॉयलरप्लेट कोड काफी कम हो सकता है और आपकी टाइप परिभाषाएं अधिक अभिव्यंजक और समझने में आसान हो सकती हैं।

इन्हें ऐसे फंक्शन्स के रूप में सोचें जो वैल्यूज के बजाय टाइप्स पर काम करते हैं। वे इनपुट के रूप में एक टाइप लेते हैं और आउटपुट के रूप में एक संशोधित टाइप लौटाते हैं। यह आपको न्यूनतम कोड के साथ जटिल टाइप संबंध और ट्रांसफॉर्मेशन बनाने की अनुमति देता है।

यूटिलिटी टाइप्स का उपयोग क्यों करें?

आपके टाइपस्क्रिप्ट प्रोजेक्ट्स में यूटिलिटी टाइप्स को शामिल करने के कई ठोस कारण हैं:

आवश्यक टाइपस्क्रिप्ट यूटिलिटी टाइप्स

आइए टाइपस्क्रिप्ट में सबसे अधिक उपयोग किए जाने वाले और फायदेमंद यूटिलिटी टाइप्स में से कुछ का पता लगाएं। हम उनके उद्देश्य, सिंटैक्स को कवर करेंगे, और उनके उपयोग को स्पष्ट करने के लिए व्यावहारिक उदाहरण प्रदान करेंगे।

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", // केवल नाम प्रॉपर्टी प्रदान की गई है
};

उपयोग का मामला: किसी ऑब्जेक्ट को केवल कुछ प्रॉपर्टीज के साथ अपडेट करना। उदाहरण के लिए, एक यूजर प्रोफ़ाइल अपडेट फ़ॉर्म की कल्पना करें। आप उपयोगकर्ताओं को एक ही बार में हर फ़ील्ड को अपडेट करने की आवश्यकता नहीं रखना चाहते हैं।

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 की सभी प्रॉपर्टीज को रीड-ओनली बना देता है। यह आपको किसी ऑब्जेक्ट के बनने के बाद उसकी प्रॉपर्टीज को गलती से संशोधित करने से रोकता है। यह अपरिवर्तनीयता (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' को असाइन नहीं किया जा सकता क्योंकि यह एक रीड-ओनली प्रॉपर्टी है।

उपयोग का मामला: अपरिवर्तनीय डेटा संरचनाएं बनाना, जैसे कॉन्फ़िगरेशन ऑब्जेक्ट्स या डेटा ट्रांसफर ऑब्जेक्ट्स (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 के पैरामीटर टाइप्स को एक टपल के रूप में निकालता है। यह तब उपयोगी होता है जब आप जानना चाहते हैं कि कोई फंक्शन किस प्रकार के आर्गुमेंट्स स्वीकार करता है।

सिंटैक्स:

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"

यूटिलिटी टाइप्स का उपयोग करने के लिए सर्वोत्तम अभ्यास

निष्कर्ष

टाइपस्क्रिप्ट यूटिलिटी टाइप्स शक्तिशाली उपकरण हैं जो आपके कोड की टाइप सुरक्षा, पुन: प्रयोज्यता और रखरखाव में काफी सुधार कर सकते हैं। इन यूटिलिटी टाइप्स में महारत हासिल करके, आप अधिक मजबूत और अभिव्यंजक टाइपस्क्रिप्ट एप्लिकेशन लिख सकते हैं। इस गाइड ने सबसे आवश्यक टाइपस्क्रिप्ट यूटिलिटी टाइप्स को कवर किया है, जिसमें आपको उन्हें अपने प्रोजेक्ट्स में शामिल करने में मदद करने के लिए व्यावहारिक उदाहरण और कार्रवाई योग्य अंतर्दृष्टि प्रदान की गई है।

इन यूटिलिटी टाइप्स के साथ प्रयोग करना याद रखें और यह पता लगाएं कि उनका उपयोग आपके अपने कोड में विशिष्ट समस्याओं को हल करने के लिए कैसे किया जा सकता है। जैसे-जैसे आप उनसे अधिक परिचित होते जाएंगे, आप खुद को क्लीनर, अधिक रखरखाव योग्य और अधिक टाइप-सुरक्षित टाइपस्क्रिप्ट एप्लिकेशन बनाने के लिए उनका अधिक से अधिक उपयोग करते हुए पाएंगे। चाहे आप वेब एप्लिकेशन, सर्वर-साइड एप्लिकेशन, या बीच में कुछ भी बना रहे हों, यूटिलिटी टाइप्स आपके डेवलपमेंट वर्कफ़्लो और आपके कोड की गुणवत्ता में सुधार के लिए उपकरणों का एक मूल्यवान सेट प्रदान करते हैं। इन अंतर्निहित टाइप मैनिपुलेशन टूल्स का लाभ उठाकर, आप टाइपस्क्रिप्ट की पूरी क्षमता को अनलॉक कर सकते हैं और ऐसा कोड लिख सकते हैं जो अभिव्यंजक और मजबूत दोनों हो।