Tingimuslik tüübipäring: 'infer' võtmesõna meisterlik valdamine TypeScriptis

TypeScripti tüübisüsteem pakub võimsaid tööriistu robustse ja hooldatava koodi loomiseks. Nende tööriistade seas paistavad tingimuslikud tüübid silma kui mitmekülgne mehhanism keeruliste tüübisuhete väljendamiseks. Eelkõige avab infer võtmesõna tingimuslikes tüüpides täiustatud võimalusi, lubades keerukat tüüpide eraldamist ja manipuleerimist. See põhjalik juhend uurib infer'i keerukusi, pakkudes praktilisi näiteid ja teadmisi, mis aitavad teil selle kasutamist meisterlikult valdama õppida.

Tingimuslike tüüpide mõistmine

Enne infer'i süvenemist on oluline mõista tingimuslike tüüpide aluseid. Tingimuslikud tüübid võimaldavad teil määratleda tüüpe, mis sõltuvad tingimusest, sarnaselt JavaScripti kolmekomponendilisele operaatorile. Süntaks järgib seda mustrit:

            T extends U ? X : Y
            

              
                Copy
              
            
          

Siin, kui tüüp T on omistatav tüübile U, on tulemuseks olev tüüp X; vastasel juhul on see Y.

Näide:

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

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

              
                Copy
              
            
          

See lihtne näide demonstreerib, kuidas tingimuslikke tüüpe saab kasutada, et määrata, kas tüüp on string või mitte. See kontseptsioon laieneb keerukamatele stsenaariumidele, sillutades teed infer võtmesõnale.

'infer' võtmesõna tutvustus

infer võtmesõna kasutatakse tingimusliku tüübi true harus, et tuua sisse tüübimuutuja, mida saab tuletada kontrollitavast tüübist. See võimaldab teil eraldada tüübi konkreetseid osi ja kasutada neid tulemuseks olevas tüübis.

Süntaks:

            T extends (infer R) ? X : Y
            

              
                Copy
              
            
          

Selles süntaksis on R tüübimuutuja, mis tuletatakse T struktuurist. Kui T vastab mustrile, hoiab R tuletatud tüüpi ja tulemuseks olev tüüp on X; vastasel juhul on see Y.

'infer' kasutamise põhinäited

1. Funktsiooni tagastustüübi tuletamine

Levinud kasutusjuhtum on funktsiooni tagastustüübi tuletamine. Seda on võimalik saavutada järgmise tingimusliku tüübiga:

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

              
                Copy
              
            
          

Selgitus:

• T extends (...args: any) => any: See piirang tagab, et T on funktsioon.
• (...args: any) => infer R: See muster sobitub funktsiooniga ja tuletab tagastustüübi kui R.
• R : any: Kui T ei ole funktsioon, on tulemuseks olev tüüp any.

Näide:

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

type GreetingReturnType = ReturnType<typeof greet>; // tüüp GreetingReturnType = string

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

type CalculateReturnType = ReturnType<typeof calculate>; // tüüp CalculateReturnType = number

            

              
                Copy
              
            
          

See näide demonstreerib, kuidas ReturnType eraldab edukalt funktsioonide greet ja calculate tagastustüübid.

2. Massiivi elemendi tüübi tuletamine

Teine sage kasutusjuhtum on massiivi elemendi tüübi eraldamine:

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

              
                Copy
              
            
          

Selgitus:

• T extends (infer U)[]: See muster sobitub massiiviga ja tuletab elemendi tüübi kui U.
• U : never: Kui T ei ole massiiv, on tulemuseks olev tüüp never.

Näide:

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

type NotAnArray = ElementType<number>; // tüüp NotAnArray = never
            

              
                Copy
              
            
          

See näitab, kuidas ElementType tuletab korrektselt erinevate massiivitüüpide elemendi tüübi.

'infer' edasijõudnud kasutus

1. Funktsiooni parameetrite tuletamine

Sarnaselt tagastustüübi tuletamisele saate tuletada funktsiooni parameetrid, kasutades infer'i ja korteeže (tuples):

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

              
                Copy
              
            
          

Selgitus:

• T extends (...args: any) => any: See piirang tagab, et T on funktsioon.
• (...args: infer P) => any: See muster sobitub funktsiooniga ja tuletab parameetrite tüübid kui korteeži P.
• P : never: Kui T ei ole funktsioon, on tulemuseks olev tüüp never.

Näide:

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

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

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

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

              
                Copy
              
            
          

Parameters eraldab parameetrite tüübid korteežina, säilitades funktsiooni argumentide järjekorra ja tüübid.

2. Omaduste eraldamine objektitüübist

infer'i saab kasutada ka konkreetsete omaduste eraldamiseks objektitüübist. See nõuab keerukamat tingimuslikku tüüpi, kuid võimaldab võimsat tüübimanipulatsiooni.

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

              
                Copy
              
            
          

Selgitus:

• K in keyof T: See itereerib üle kõikide tüübi T võtmete.
• T[K] extends U ? K : never: See tingimuslik tüüp kontrollib, kas võtmega K seotud omaduse tüüp (st T[K]) on omistatav tüübile U. Kui on, siis võti K lisatakse tulemuseks olevasse tüüpi; vastasel juhul jäetakse see never abil välja.
• Kogu konstruktsioon loob uue objektitüübi, mis sisaldab ainult neid omadusi, mille tüübid laiendavad U'd.

Näide:

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


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

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

            

              
                Copy
              
            
          

PickByType võimaldab teil luua uue tüübi, mis sisaldab olemasolevast tüübist ainult teatud tüüpi omadusi.

3. Pesastatud tüüpide tuletamine

infer'i saab aheldada ja pesastada, et eraldada tüüpe sügavalt pesastatud struktuuridest. Näiteks, kaalume sisima elemendi tüübi eraldamist pesastatud massiivist.

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

              
                Copy
              
            
          

Selgitus:

• T extends (infer U)[]: See kontrollib, kas T on massiiv, ja tuletab elemendi tüübi kui U.
• DeepArrayElement<U>: Kui T on massiiv, kutsub tüüp rekursiivselt välja DeepArrayElement'i elemendi tüübiga U.
• T: Kui T ei ole massiiv, tagastab tüüp T enda.

Näide:

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

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

type RegularNumber = DeepArrayElement<number>; // tüüp RegularNumber = number
            

              
                Copy
              
            
          

See rekursiivne lähenemine võimaldab teil eraldada elemendi tüübi massiivi sügavaimalt pesastatud tasemelt.

Reaalse maailma rakendused

infer võtmesõna leiab rakendust erinevates stsenaariumides, kus on vajalik dünaamiline tüübimanipulatsioon. Siin on mõned praktilised näited:

1. Tüübiturvalise sündmuste edastaja loomine

Saate kasutada infer'i, et luua tüübiturvaline sündmuste edastaja (event emitter), mis tagab, et sündmuste käsitlejad saavad õiget tüüpi andmeid.

            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
              
            
          

Selles näites kasutab EventData tingimuslikke tüüpe ja infer'i, et eraldada konkreetse sündmuse nimega seotud andmetüüp, tagades, et sündmuste käsitlejad saavad õiget tüüpi andmeid.

2. Tüübiturvalise redutseerija implementeerimine

Saate kasutada infer'i, et luua tüübiturvaline redutseerija funktsioon (reducer) olekuhalduseks.

            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;

// Näidistoimingud
type IncrementAction = Action<'INCREMENT'>;
type DecrementAction = Action<'DECREMENT'>;
type SetValueAction = Action<'SET_VALUE', number>;


// Näidisolek
interface CounterState {
  value: number;
}

// Näidisredutseerija
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;
  }
};

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

            

              
                Copy
              
            
          

Kuigi see näide ei kasuta otseselt `infer`'i, loob see aluse keerukamatele redutseerija stsenaariumidele. `infer`'i saab rakendada, et dünaamiliselt eraldada `payload` tüüp erinevatest `Action` tüüpidest, võimaldades rangemat tüübikontrolli redutseerija funktsioonis. See on eriti kasulik suuremates rakendustes, kus on arvukalt toiminguid ja keerulisi olekustruktuure.

3. Dünaamiline tüüpide genereerimine API vastustest

API-dega töötades saate kasutada infer'i, et automaatselt genereerida TypeScripti tüüpe API vastuste struktuurist. See aitab tagada tüübiturvalisuse väliste andmeallikatega suhtlemisel.

Vaatleme lihtsustatud stsenaariumi, kus soovite eraldada andmetüübi üldisest API vastusest:

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

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

// Näidis API vastus
type User = {
  id: number;
  name: string;
  email: string;
};

type UserApiResponse = ApiResponse<User>;

type ExtractedUser = ExtractDataType<UserApiResponse>; // tüüp ExtractedUser = User

            

              
                Copy
              
            
          

ExtractDataType kasutab infer'i, et eraldada tüüp U tüübist ApiResponse<U>, pakkudes tüübiturvalist viisi API poolt tagastatud andmestruktuurile juurdepääsuks.

Parimad praktikad ja kaalutlused

• Selgus ja loetavus: Kasutage kirjeldavaid tüübimuutujate nimesid (nt ReturnType lihtsalt R asemel), et parandada koodi loetavust.
• Jõudlus: Kuigi infer on võimas, võib selle liigne kasutamine mõjutada tüübikontrolli jõudlust. Kasutage seda mõistlikult, eriti suurtes koodibaasides.
• Vigade käsitlemine: Pakkuge alati varutüüp (nt any või never) tingimusliku tüübi false harus, et käsitleda juhtumeid, kus tüüp ei vasta oodatud mustrile.
• Keerukus: Vältige liiga keerulisi tingimuslikke tüüpe pesastatud infer lausetega, kuna need võivad muutuda raskesti mõistetavaks ja hooldatavaks. Vajadusel refaktoreerige oma kood väiksemateks ja paremini hallatavateks tüüpideks.
• Testimine: Testige oma tingimuslikke tüüpe põhjalikult erinevate sisendtüüpidega, et tagada nende ootuspärane käitumine.

Globaalsed kaalutlused

TypeScripti ja infer'i kasutamisel globaalses kontekstis arvestage järgmisega:

• Lokaliseerimine ja rahvusvahelistamine (i18n): Tüübid võivad vajada kohandamist erinevate lokaatide ja andmevormingutega. Kasutage tingimuslikke tüüpe ja `infer`'i, et dünaamiliselt käsitleda erinevaid andmestruktuure vastavalt lokaadipõhistele nõuetele. Näiteks kuupäevi ja valuutasid saab riigiti erinevalt esitada.
• API disain globaalsele publikule: Disainige oma API-d globaalset ligipääsetavust silmas pidades. Kasutage järjepidevaid andmestruktuure ja -vorminguid, mis on kergesti mõistetavad ja töödeldavad olenemata kasutaja asukohast. Tüübimääratlused peaksid seda järjepidevust peegeldama.
• Ajavööndid: Kuupäevade ja kellaaegadega tegelemisel olge teadlik ajavööndite erinevustest. Kasutage sobivaid teeke (nt Luxon, date-fns) ajavööndite teisenduste haldamiseks ja täpse andmete esituse tagamiseks erinevates piirkondades. Kaaluge kuupäevade ja kellaaegade esitamist UTC-vormingus oma API vastustes.
• Kultuurilised erinevused: Olge teadlik kultuurilistest erinevustest andmete esitamisel ja tõlgendamisel. Näiteks nimedel, aadressidel ja telefoninumbritel võivad eri riikides olla erinevad vormingud. Veenduge, et teie tüübimääratlused suudaksid neid variatsioone arvesse võtta.
• Valuutakäsitlus: Rahaliste väärtustega tegelemisel kasutage järjepidevat valuutaesitust (nt ISO 4217 valuutakoodid) ja käsitlege valuutateisendusi asjakohaselt. Kasutage valuuta manipuleerimiseks mõeldud teeke, et vältida täpsusprobleeme ja tagada täpsed arvutused.

Näiteks kaaluge stsenaariumi, kus te hangite kasutajaprofiile erinevatest piirkondadest ja aadressivorming varieerub sõltuvalt riigist. Saate kasutada tingimuslikke tüüpe ja `infer`'i, et dünaamiliselt kohandada tüübimääratlust vastavalt kasutaja asukohale:

            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; // Lisa profiilile riigikood
};

// Näidiskasutus
type USUserProfile = UserProfile<'US'>; // Omab USA aadressivormingut
type CAUserProfile = UserProfile<'CA'>; // Omab Kanada aadressivormingut
type GenericUserProfile = UserProfile<'DE'>; // Omab üldist (rahvusvahelist) aadressivormingut

            

              
                Copy
              
            
          

Lisasades `countryCode` `UserProfile` tüübile ja kasutades sellel koodil põhinevaid tingimuslikke tüüpe, saate dünaamiliselt kohandada `address` tüüpi, et see vastaks iga piirkonna oodatud vormingule. See võimaldab tüübiturvaliselt käsitleda erinevaid andmevorminguid eri riikides.

Kokkuvõte

infer võtmesõna on võimas täiendus TypeScripti tüübisüsteemile, võimaldades keerukat tüübimanipulatsiooni ja -eraldust tingimuslikes tüüpides. Valdades infer'i, saate luua robustsemat, tüübiturvalisemat ja hooldatavamat koodi. Alates funktsioonide tagastustüüpide tuletamisest kuni omaduste eraldamiseni keerulistest objektidest on võimalused laialdased. Pidage meeles, et kasutage infer'i mõistlikult, eelistades selgust ja loetavust, et tagada teie koodi arusaadavus ja hooldatavus pikas perspektiivis.

See juhend on andnud põhjaliku ülevaate infer'ist ja selle rakendustest. Katsetage esitatud näidetega, uurige täiendavaid kasutusjuhtumeid ja kasutage infer'i oma TypeScripti arendustöövoo täiustamiseks.