कंडीशनल टाइप इंफेरेंस: टाइपस्क्रिप्ट में 'infer' कीवर्ड में महारत हासिल करना

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

कंडीशनल टाइप को समझना

infer में गोता लगाने से पहले, कंडीशनल टाइप के मूल सिद्धांतों को समझना महत्वपूर्ण है। कंडीशनल टाइप आपको ऐसे टाइप को परिभाषित करने की अनुमति देते हैं जो एक शर्त पर निर्भर करते हैं, जैसा कि जावास्क्रिप्ट में टर्नरी ऑपरेटर में होता है। सिंटैक्स इस पैटर्न का पालन करता है:

            T extends U ? X : Y
            

              
                Copy
              
            
          

यहां, यदि टाइप T, टाइप U को असाइन करने योग्य है, तो परिणामी टाइप X होगा; अन्यथा, यह Y होगा।

उदाहरण:

            type IsString<T> = T extends string ? true : false;

type StringCheck = IsString<string>; // type StringCheck = true
type NumberCheck = IsString<number>; // type NumberCheck = false
            

              
                Copy
              
            
          

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

'infer' कीवर्ड का परिचय

infer कीवर्ड का उपयोग कंडीशनल टाइप की true शाखा के भीतर एक टाइप वेरिएबल को प्रस्तुत करने के लिए किया जाता है जिसे जाँचे जा रहे टाइप से अनुमानित किया जा सकता है। यह आपको टाइप के विशिष्ट भागों को निकालने और उन्हें परिणामी टाइप में उपयोग करने की अनुमति देता है।

सिंटैक्स:

            T extends (infer R) ? X : Y
            

              
                Copy
              
            
          

इस सिंटैक्स में, R एक टाइप वेरिएबल है जिसे T की संरचना से अनुमानित किया जाएगा। यदि T पैटर्न से मेल खाता है, तो R अनुमानित टाइप को धारण करेगा, और परिणामी टाइप X होगा; अन्यथा, यह Y होगा।

'infer' के उपयोग के मूल उदाहरण

1. एक फ़ंक्शन के रिटर्न टाइप का अनुमान लगाना

एक सामान्य उपयोग का मामला एक फ़ंक्शन के रिटर्न टाइप का अनुमान लगाना है। इसे निम्नलिखित कंडीशनल टाइप से प्राप्त किया जा सकता है:

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

              
                Copy
              
            
          

स्पष्टीकरण:

• T extends (...args: any) => any: यह बाधा सुनिश्चित करती है कि T एक फ़ंक्शन है।
• (...args: any) => infer R: यह पैटर्न एक फ़ंक्शन से मेल खाता है और रिटर्न टाइप को R के रूप में अनुमानित करता है।
• R : any: यदि T एक फ़ंक्शन नहीं है, तो परिणामी टाइप any है।

उदाहरण:

            function greet(name: string): string {
  return `Hello, ${name}!`;
}

type GreetingReturnType = ReturnType<typeof greet>; // type GreetingReturnType = string

function calculate(a: number, b: number): number {
  return a + b;
}

type CalculateReturnType = ReturnType<typeof calculate>; // type CalculateReturnType = number

            

              
                Copy
              
            
          

यह उदाहरण दर्शाता है कि ReturnType greet और calculate फ़ंक्शन के रिटर्न टाइप को सफलतापूर्वक कैसे निकालता है।

2. एरे एलिमेंट टाइप का अनुमान लगाना

एक और बार-बार उपयोग किया जाने वाला मामला एक एरे के एलिमेंट टाइप को निकालना है:

            type ElementType<T> = T extends (infer U)[] ? U : never;
            

              
                Copy
              
            
          

स्पष्टीकरण:

• T extends (infer U)[]: यह पैटर्न एक एरे से मेल खाता है और एलिमेंट टाइप को U के रूप में अनुमानित करता है।
• U : never: यदि T एक एरे नहीं है, तो परिणामी टाइप never है।

उदाहरण:

            type StringArrayElement = ElementType<string[]>; // type StringArrayElement = string
type NumberArrayElement = ElementType<number[]>; // type NumberArrayElement = number
type MixedArrayElement = ElementType<(string | number)[]>; // type MixedArrayElement = string | number

type NotAnArray = ElementType<number>; // type NotAnArray = never
            

              
                Copy
              
            
          

यह दर्शाता है कि ElementType विभिन्न एरे टाइप के एलिमेंट टाइप को कैसे सही ढंग से अनुमानित करता है।

'infer' का उन्नत उपयोग

1. एक फ़ंक्शन के मापदंडों का अनुमान लगाना

रिटर्न टाइप का अनुमान लगाने के समान, आप infer और ट्यूपल का उपयोग करके एक फ़ंक्शन के मापदंडों का अनुमान लगा सकते हैं:

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

              
                Copy
              
            
          

स्पष्टीकरण:

• T extends (...args: any) => any: यह बाधा सुनिश्चित करती है कि T एक फ़ंक्शन है।
• (...args: infer P) => any: यह पैटर्न एक फ़ंक्शन से मेल खाता है और पैरामीटर टाइप को एक ट्यूपल P के रूप में अनुमानित करता है।
• P : never: यदि T एक फ़ंक्शन नहीं है, तो परिणामी टाइप never है।

उदाहरण:

            function logMessage(message: string, level: 'info' | 'warn' | 'error'): void {
  console.log(`[${level.toUpperCase()}] ${message}`);
}

type LogMessageParams = Parameters<typeof logMessage>; // type LogMessageParams = [message: string, level: "info" | "warn" | "error"]

function processData(data: any[], callback: (item: any) => void): void {
  data.forEach(callback);
}

type ProcessDataParams = Parameters<typeof processData>; // type ProcessDataParams = [data: any[], callback: (item: any) => void]
            

              
                Copy
              
            
          

Parameters पैरामीटर टाइप को एक ट्यूपल के रूप में निकालता है, फ़ंक्शन के तर्क के क्रम और टाइप को संरक्षित करता है।

2. ऑब्जेक्ट टाइप से गुण निकालना

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

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

              
                Copy
              
            
          

स्पष्टीकरण:

• K in keyof T: यह टाइप T की सभी कुंजियों पर पुनरावृति करता है।
• T[K] extends U ? K : never: यह कंडीशनल टाइप जांचता है कि कुंजी K पर प्रॉपर्टी का टाइप (अर्थात, T[K]) टाइप U को असाइन करने योग्य है या नहीं। यदि ऐसा है, तो कुंजी K को परिणामी टाइप में शामिल किया जाता है; अन्यथा, इसे never का उपयोग करके बाहर रखा जाता है।
• संपूर्ण निर्माण केवल उन्हीं गुणों के साथ एक नया ऑब्जेक्ट टाइप बनाता है जिनके टाइप U का विस्तार करते हैं।

उदाहरण:

            interface Person {
  name: string;
  age: number;
  city: string;
  country: string;
}


type StringProperties = PickByType<Person, string>; // type StringProperties = { name: string; city: string; country: string; }

type NumberProperties = PickByType<Person, number>; // type NumberProperties = { age: number; }

            

              
                Copy
              
            
          

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

3. नेस्टेड टाइप का अनुमान लगाना

infer को गहरे नेस्टेड संरचनाओं से टाइप निकालने के लिए चेन किया और नेस्टेड किया जा सकता है। उदाहरण के लिए, एक नेस्टेड एरे के सबसे अंदरूनी एलिमेंट के टाइप को निकालने पर विचार करें।

            type DeepArrayElement<T> = T extends (infer U)[] ? DeepArrayElement<U> : T;
            

              
                Copy
              
            
          

स्पष्टीकरण:

• T extends (infer U)[]: यह जांचता है कि T एक एरे है या नहीं और एलिमेंट टाइप को U के रूप में अनुमानित करता है।
• DeepArrayElement<U>: यदि T एक एरे है, तो टाइप रिकर्सिवली DeepArrayElement को एलिमेंट टाइप U के साथ कॉल करता है।
• T: यदि T एक एरे नहीं है, तो टाइप स्वयं T लौटाता है।

उदाहरण:

            type NestedStringArray = string[][][];
type DeepString = DeepArrayElement<NestedStringArray>; // type DeepString = string

type MixedNestedArray = (number | string)[][][][];
type DeepMixed = DeepArrayElement<MixedNestedArray>; // type DeepMixed = string | number

type RegularNumber = DeepArrayElement<number>; // type RegularNumber = number
            

              
                Copy
              
            
          

यह रिकर्सिव दृष्टिकोण आपको एक एरे में नेस्टिंग के सबसे गहरे स्तर पर एलिमेंट के टाइप को निकालने की अनुमति देता है।

वास्तविक-विश्व अनुप्रयोग

infer कीवर्ड विभिन्न परिदृश्यों में अनुप्रयोग पाता है जहां गतिशील टाइप हेरफेर की आवश्यकता होती है। यहां कुछ व्यावहारिक उदाहरण दिए गए हैं:

1. एक टाइप-सेफ इवेंट एमिटर बनाना

आप infer का उपयोग करके एक टाइप-सेफ इवेंट एमिटर बना सकते हैं जो यह सुनिश्चित करता है कि इवेंट हैंडलर सही डेटा टाइप प्राप्त करें।

            type EventMap = {
  'data': { value: string };
  'error': { message: string };
};

type EventName<T extends EventMap> = keyof T;

type EventData<T extends EventMap, K extends EventName<T>> = T[K];

type EventHandler<T extends EventMap, K extends EventName<T>> = (data: EventData<T, K>) => void;

class EventEmitter<T extends EventMap> {
  private listeners: { [K in EventName<T>]?: EventHandler<T, K>[] } = {};

  on<K extends EventName<T>>(event: K, handler: EventHandler<T, K>): void {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event]!.push(handler);
  }

  emit<K extends EventName<T>>(event: K, data: EventData<T, K>): void {
    this.listeners[event]?.forEach(handler => handler(data));
  }
}


const emitter = new EventEmitter<EventMap>();

emitter.on('data', (data) => {
  console.log(`Received data: ${data.value}`);
});

emitter.on('error', (error) => {
  console.error(`An error occurred: ${error.message}`);
});

emitter.emit('data', { value: 'Hello, world!' });

emitter.emit('error', { message: 'Something went wrong.' });

            

              
                Copy
              
            
          

इस उदाहरण में, EventData कंडीशनल टाइप और infer का उपयोग एक विशिष्ट इवेंट नाम से जुड़े डेटा टाइप को निकालने के लिए करता है, यह सुनिश्चित करता है कि इवेंट हैंडलर सही प्रकार का डेटा प्राप्त करें।

2. एक टाइप-सेफ रिड्यूसर लागू करना

आप स्टेट मैनेजमेंट के लिए एक टाइप-सेफ रिड्यूसर फ़ंक्शन बनाने के लिए infer का लाभ उठा सकते हैं।

            type Action<T extends string, P = undefined> = P extends undefined
  ? { type: T }
  : { type: T; payload: P };

type Reducer<S, A extends Action<string>> = (state: S, action: A) => S;

// Example Actions
type IncrementAction = Action<'INCREMENT'>;
type DecrementAction = Action<'DECREMENT'>;
type SetValueAction = Action<'SET_VALUE', number>;


// Example State
interface CounterState {
  value: number;
}

// Example Reducer
const counterReducer: Reducer<CounterState, IncrementAction | DecrementAction | SetValueAction> = (
  state: CounterState,
  action: IncrementAction | DecrementAction | SetValueAction
): CounterState => {
  switch (action.type) {
    case 'INCREMENT':
      return { ...state, value: state.value + 1 };
    case 'DECREMENT':
      return { ...state, value: state.value - 1 };
    case 'SET_VALUE':
      return { ...state, value: action.payload };
    default:
      return state;
  }
};

// Usage
const initialState: CounterState = { value: 0 };
const newState1 = counterReducer(initialState, { type: 'INCREMENT' }); // newState1.value is 1
const newState2 = counterReducer(newState1, { type: 'SET_VALUE', payload: 10 }); // newState2.value is 10

            

              
                Copy
              
            
          

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

3. एपीआई प्रतिक्रियाओं से गतिशील टाइप निर्माण

एपीआई के साथ काम करते समय, आप एपीआई प्रतिक्रियाओं की संरचना से टाइपस्क्रिप्ट टाइप को स्वचालित रूप से उत्पन्न करने के लिए infer का उपयोग कर सकते हैं। यह बाहरी डेटा स्रोतों के साथ इंटरैक्ट करते समय टाइप सुरक्षा सुनिश्चित करने में मदद करता है।

एक सरलीकृत परिदृश्य पर विचार करें जहां आप एक सामान्य एपीआई प्रतिक्रिया से डेटा टाइप निकालना चाहते हैं:

            type ApiResponse<T> = {
  status: number;
  data: T;
  message?: string;
};

type ExtractDataType<T> = T extends ApiResponse<infer U> ? U : never;

// Example API Response
type User = {
  id: number;
  name: string;
  email: string;
};

type UserApiResponse = ApiResponse<User>;

type ExtractedUser = ExtractDataType<UserApiResponse>; // type ExtractedUser = User

            

              
                Copy
              
            
          

ExtractDataType infer का उपयोग ApiResponse<U> से टाइप U को निकालने के लिए करता है, जो एपीआई द्वारा लौटाए गए डेटा संरचना तक पहुंचने का एक टाइप-सेफ तरीका प्रदान करता है।

सर्वोत्तम अभ्यास और विचार

• स्पष्टता और पठनीयता: कोड पठनीयता में सुधार के लिए वर्णनात्मक टाइप वेरिएबल नाम (जैसे, केवल R के बजाय ReturnType) का उपयोग करें।
• प्रदर्शन: जबकि infer शक्तिशाली है, अत्यधिक उपयोग टाइप जांच प्रदर्शन को प्रभावित कर सकता है। इसका विवेकपूर्ण उपयोग करें, खासकर बड़े कोडबेस में।
• त्रुटि हैंडलिंग: हमेशा एक फ़ॉलबैक टाइप (जैसे, any या never) प्रदान करें कंडीशनल टाइप की false शाखा में उन मामलों को संभालने के लिए जहां टाइप अपेक्षित पैटर्न से मेल नहीं खाता है।
• जटिलता: नेस्टेड infer स्टेटमेंट के साथ अत्यधिक जटिल कंडीशनल टाइप से बचें, क्योंकि उन्हें समझना और बनाए रखना मुश्किल हो सकता है। आवश्यकता पड़ने पर अपने कोड को छोटे, अधिक प्रबंधनीय टाइप में रीफ़ैक्टर करें।
• परीक्षण: विभिन्न इनपुट टाइप के साथ अपने कंडीशनल टाइप का पूरी तरह से परीक्षण करें ताकि यह सुनिश्चित हो सके कि वे अपेक्षा के अनुरूप व्यवहार करते हैं।

वैश्विक विचार

एक वैश्विक संदर्भ में टाइपस्क्रिप्ट और infer का उपयोग करते समय, निम्नलिखित बातों पर विचार करें:

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

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

            type AddressFormat<CountryCode extends string> = CountryCode extends 'US'
    ? { street: string; city: string; state: string; zipCode: string; }
    : CountryCode extends 'CA'
    ? { street: string; city: string; province: string; postalCode: string; }
    : { addressLines: string[]; city: string; country: string; };

type UserProfile<CountryCode extends string> = {
    id: number;
    name: string;
    email: string;
    address: AddressFormat<CountryCode>;
    countryCode: CountryCode; // Add country code to profile
};

// Example Usage
type USUserProfile = UserProfile<'US'>; // Has US address format
type CAUserProfile = UserProfile<'CA'>; // Has Canadian address format
type GenericUserProfile = UserProfile<'DE'>; // Has Generic (international) address format

            

              
                Copy
              
            
          

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

निष्कर्ष

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

इस मार्गदर्शिका ने infer और इसके अनुप्रयोगों का एक व्यापक अवलोकन प्रदान किया है। दिए गए उदाहरणों के साथ प्रयोग करें, अतिरिक्त उपयोग के मामलों का पता लगाएं, और अपनी टाइपस्क्रिप्ट विकास वर्कफ़्लो को बढ़ाने के लिए infer का लाभ उठाएं।