Casi d'uso pratici di infer: rimozione dei wrapper Promise
Rimuova i wrapper dai tipi Promise, Array e personalizzati.
Casi d'uso pratici di infer: rimozione dei wrapper Promise è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.
Il problema della rimozione dei wrapper
Quando si lavora con codice asincrono, spesso si riceve Promise e si deve ottenere il valore T sottostante. La parola chiave infer rende riutilizzabile questa estrazione.
type Awaited<T> = T extends Promise<infer U> ? U : T;
type A = Awaited<Promise<string>>; // string
type B = Awaited<number>; // numberUtility Awaited integrata
TypeScript 4.5 ha introdotto Awaited, l'utility integrata che gestisce ricorsivamente le promise annidate.
type A = Awaited<Promise<Promise<string>>>; // string
// Handles arbitrary nesting automaticallyRimozione dei wrapper con profondità personalizzata
Prima che Awaited fosse integrato, gli sviluppatori utilizzavano tipi ricorsivi con infer per rimuovere i wrapper delle promise.
type DeepAwaited<T> =
T extends Promise<infer U> ? DeepAwaited<U> : T;
type A = DeepAwaited<Promise<Promise<number>>>; // numberRimozione dei wrapper dagli elementi degli array
Lo stesso pattern infer estrae il tipo degli elementi da un array, in modo equivalente all'approccio integrato T[number].
type Element<T> = T extends (infer U)[] ? U : never;
type A = Element<string[]>; // string
type B = Element<number[]>; // numberRimozione dei wrapper dai tipi Observable
Per gli Observable di RxJS, infer estrae il tipo emesso.
type ObservableType<T> = T extends Observable<infer U> ? U : never;
type A = ObservableType<Observable<User>>; // UserRimozione del wrapper dal valore restituito di una funzione
Combini ReturnType e Awaited per ottenere il valore risolto di una funzione asincrona.
async function getUser(): Promise<User> { /* ... */ }
type UserResult = Awaited<ReturnType<typeof getUser>>; // UserRimozione dei wrapper annidati
È possibile concatenare infer per gestire i tipi racchiusi in più livelli, come Promise.
type UnwrapPromiseArray<T> =
T extends Promise<infer U>
? U extends (infer V)[]
? V
: U
: T;
type A = UnwrapPromiseArray<Promise<User[]>>; // UserRimozione condizionale dei wrapper in base alla forma
Utilizzi infer per rimuovere condizionalmente i wrapper solo da determinati tipi, lasciando invariati gli altri.
type MaybeUnwrap<T> =
T extends Promise<infer U> ? U : T extends (infer V)[] ? V : T;
type A = MaybeUnwrap<Promise<string>>; // string
type B = MaybeUnwrap<number[]>; // number
type C = MaybeUnwrap<boolean>; // booleanWrapper fetch tipizzato per le API
Un wrapper fetch generico che restituisce il tipo dei dati risolti è una classica applicazione della rimozione dei wrapper basata su infer.
async function fetchData<T>(url: string): Promise<T> {
const res = await fetch(url);
return res.json() as T;
}
type UserData = Awaited<ReturnType<typeof fetchData<User>>>; // UserRimozione dei wrapper con gestione sicura degli errori
Il pattern Result combinato con infer consente di estrarre il tipo del risultato positivo da un'unione discriminata.
type Ok<T> = { ok: true; value: T };
type Err = { ok: false; error: string };
type ExtractOk<T> = T extends Ok<infer V> ? V : never;
type A = ExtractOk<Ok<number> | Err>; // numberRiepilogo: rimozione dei wrapper con infer
La parola chiave infer è uno strumento universale per estrarre tipi dai wrapper: promise, array, Observable e tipi Result. L'integrato Awaited gestisce la rimozione dei wrapper asincroni; utilizzi tipi personalizzati per le altre strutture.
Verifica rapida
Qual è il modo migliore per ottenere il tipo del valore risolto di una funzione asincrona?
Cosa ha imparato
La rimozione dei wrapper basata su infer è uno strumento pratico per il codice TypeScript asincrono. Utilizzi l'integrato Awaited per le promise e crei tipi personalizzati per rimuovere i wrapper da array, Observable e pattern Result.
Impara TypeScript con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 101
- Lezioni
- 352
Domande Frequenti
La lezione «Casi d'uso pratici di infer: rimozione dei wrapper Promise» è gratuita?
Sì — il testo completo di «Casi d'uso pratici di infer: rimozione dei wrapper Promise» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.
Cosa imparerò in «Casi d'uso pratici di infer: rimozione dei wrapper Promise»?
Rimuova i wrapper dai tipi Promise, Array e personalizzati. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare TypeScript Academy?
Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Casi d'uso pratici di infer: rimozione dei wrapper Promise»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?
Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Comprendere infer nei tipi condizionali
- Creazione da zero di ReturnType e Parameters
- Pattern di inferenza profondamente annidati
- Casi d'uso pratici di infer: rimozione dei wrapper Promise