நிபந்தனை வகை உய்த்துணர்வு: TypeScript இல் 'infer' முக்கிய சொல்லை தேர்ச்சி பெறுதல்

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

நிபந்தனை வகைகளை புரிந்துகொள்வது

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

            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' முக்கிய சொல்லை அறிமுகப்படுத்துகிறோம்

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

தொடரியல்:

            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 ஒரு வரிசையாக இருந்தால், வகை உறுப்பு வகை U உடன் DeepArrayElement ஐ மீண்டும் அழைக்கிறது.
• 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` ஐப் பயன்படுத்தவில்லை என்றாலும், இது மிகவும் சிக்கலான குறைப்பு காட்சிகளுக்கு அடித்தளம் அமைக்கிறது. வெவ்வேறு `Action` வகைகளிலிருந்து `payload` வகையை இயக்கவியல் ரீதியாகப் பிரித்தெடுக்க `infer` ஐப் பயன்படுத்தலாம், குறைப்புச் செயல்பாட்டின் உள்ளே கடுமையான வகைச் சரிபார்ப்பை அனுமதிக்கிறது. பல செயல்கள் மற்றும் சிக்கலான நிலை கட்டமைப்புகள் கொண்ட பெரிய பயன்பாடுகளில் இது மிகவும் பயனுள்ளதாக இருக்கும்.

3. API பதில்களிலிருந்து டைனமிக் வகை உருவாக்கம்

APIகளுடன் பணிபுரியும் போது, API பதில்களின் கட்டமைப்பிலிருந்து TypeScript வகைகளை தானாக உருவாக்க infer ஐப் பயன்படுத்தலாம். இது வெளிப்புற தரவு மூலங்களுடன் தொடர்பு கொள்ளும்போது வகை பாதுகாப்பை உறுதிப்படுத்த உதவுகிறது.

ஒரு பொதுவான API பதிலிலிருந்து தரவு வகையை பிரித்தெடுக்க விரும்பும் எளிமைப்படுத்தப்பட்ட சூழ்நிலையை கவனியுங்கள்:

            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 ApiResponse<U> இலிருந்து வகை U ஐப் பிரித்தெடுக்க infer ஐப் பயன்படுத்துகிறது, API ஆல் திரும்பப் பெறப்பட்ட தரவு கட்டமைப்பை அணுகுவதற்கான வகை-பாதுகாப்பான வழியை வழங்குகிறது.

சிறந்த நடைமுறைகள் மற்றும் பரிசீலனைகள்

• தெளிவு மற்றும் படிக்கக்கூடிய தன்மை: குறியீடு படிக்கக்கூடிய தன்மையை மேம்படுத்த விளக்கமான வகை மாறிப் பெயர்களைப் பயன்படுத்தவும் (எ.கா., R என்பதற்குப் பதிலாக ReturnType).
• செயல்திறன்: infer சக்திவாய்ந்ததாக இருந்தாலும், அதிகப்படியான பயன்பாடு வகை சரிபார்ப்பு செயல்திறனை பாதிக்கலாம். குறிப்பாக பெரிய குறியீடு தளங்களில் அதை விவேகத்துடன் பயன்படுத்தவும்.
• பிழை கையாளுதல்: வகை எதிர்பார்க்கப்படும் முறைக்கு பொருந்தாத சந்தர்ப்பங்களைக் கையாள நிபந்தனை வகையின் false கிளையில் எப்போதும் ஒரு ஃபால்பேக் வகையை (எ.கா., any அல்லது never) வழங்கவும்.
• சிக்கலானது: உள்ளமைக்கப்பட்ட infer அறிக்கைகளுடன் அதிக சிக்கலான நிபந்தனை வகைகளைத் தவிர்க்கவும், ஏனெனில் அவை புரிந்து கொள்ளவும் பராமரிக்கவும் கடினமாகிவிடும். தேவைப்படும்போது உங்கள் குறியீட்டை சிறிய, நிர்வகிக்கக்கூடிய வகைகளாக மறுஉருவாக்கவும்.
• சோதனை: அவை எதிர்பார்த்தபடி செயல்படுவதை உறுதிசெய்ய பல்வேறு உள்ளீட்டு வகைகளுடன் உங்கள் நிபந்தனை வகைகளை முழுமையாக சோதிக்கவும்.

உலகளாவிய பரிசீலனைகள்

ஒரு உலகளாவிய சூழலில் TypeScript மற்றும் infer ஐப் பயன்படுத்தும் போது, ​​பின்வருவனவற்றைக் கவனியுங்கள்:

• உள்ளூர்மயமாக்கல் மற்றும் சர்வதேசமயமாக்கல் (i18n): வகைகள் வெவ்வேறு உள்ளூர் இடங்கள் மற்றும் தரவு வடிவங்களுக்கு ஏற்றதாக இருக்க வேண்டும். இடம் சார்ந்த தேவைகளின் அடிப்படையில் மாறும் தரவு கட்டமைப்புகளை இயக்கவியல் ரீதியாக கையாள நிபந்தனை வகைகள் மற்றும் `infer` ஐப் பயன்படுத்தவும். உதாரணமாக, தேதிகள் மற்றும் நாணயங்கள் வெவ்வேறு நாடுகளில் வித்தியாசமாக குறிப்பிடப்படலாம்.
• உலகளாவிய பார்வையாளர்களுக்கான API வடிவமைப்பு: உங்கள் APIகளை உலகளாவிய அணுகலை மனதில் கொண்டு வடிவமைக்கவும். பயனரின் இருப்பிடத்தைப் பொருட்படுத்தாமல் புரிந்துகொள்வதற்கும் செயலாக்குவதற்கும் எளிதான நிலையான தரவு கட்டமைப்புகள் மற்றும் வடிவங்களைப் பயன்படுத்தவும். வகை வரையறைகள் இந்த நிலைத்தன்மையைப் பிரதிபலிக்க வேண்டும்.
• நேர மண்டலங்கள்: தேதிகள் மற்றும் நேரங்களைக் கையாளும் போது, ​​நேர மண்டல வேறுபாடுகளை நினைவில் கொள்ளுங்கள். நேர மண்டல மாற்றங்களைக் கையாள பொருத்தமான லைப்ரரிகளைப் பயன்படுத்தவும் (எ.கா., Luxon, date-fns) மற்றும் வெவ்வேறு பகுதிகளில் துல்லியமான தரவு பிரதிநிதித்துவத்தை உறுதிப்படுத்தவும். உங்கள் API பதில்களில் தேதிகள் மற்றும் நேரங்களை UTC வடிவத்தில் பிரதிநிதித்துவப்படுத்துவதைக் கவனியுங்கள்.
• கலாச்சார வேறுபாடுகள்: தரவு பிரதிநிதித்துவம் மற்றும் விளக்கத்தில் கலாச்சார வேறுபாடுகளை அறிந்திருங்கள். உதாரணமாக, பெயர்கள், முகவரிகள் மற்றும் தொலைபேசி எண்கள் வெவ்வேறு நாடுகளில் வெவ்வேறு வடிவங்களைக் கொண்டிருக்கலாம். உங்கள் வகை வரையறைகள் இந்த மாறுபாடுகளுக்கு இடமளிக்க முடியும் என்பதை உறுதிப்படுத்தவும்.
• நாணயக் கையாளுதல்: நாணய மதிப்புகளைக் கையாளும் போது, ​​நிலையான நாணயப் பிரதிநிதித்துவத்தைப் பயன்படுத்தவும் (எ.கா., ISO 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 முக்கிய சொல் TypeScript இன் வகை அமைப்புக்கு ஒரு சக்திவாய்ந்த கூடுதலாகும், இது நிபந்தனை வகைகளுக்குள் அதிநவீன வகை கையாளுதல் மற்றும் பிரித்தெடுத்தலை செயல்படுத்துகிறது. infer ஐ தேர்ச்சி பெறுவதன் மூலம், நீங்கள் அதிக வலுவான, வகை-பாதுகாப்பான மற்றும் பராமரிக்கக்கூடிய குறியீட்டை உருவாக்க முடியும். செயல்பாடு திரும்பும் வகைகளை உய்த்தறிவது முதல் சிக்கலான பொருட்களிலிருந்து பண்புகளைப் பிரித்தெடுப்பது வரை, சாத்தியங்கள் அதிகம். infer ஐ விவேகத்துடன் பயன்படுத்தவும், தெளிவு மற்றும் படிக்கக்கூடிய தன்மைக்கு முன்னுரிமை அளிக்கவும், இதன் மூலம் உங்கள் குறியீடு நீண்ட காலத்திற்கு புரிந்து கொள்ளக்கூடியதாகவும் பராமரிக்கக்கூடியதாகவும் இருப்பதை உறுதிப்படுத்தவும்.

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