Tipi condizionali distributivi
Controlli come i condizionali vengono distribuiti sulle union.
Tipi condizionali distributivi è 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.
Un comportamento sorprendente
I tipi condizionali hanno una regola speciale: quando il tipo verificato è un parametro di tipo nudo e si passa un'unione, il condizionale si distribuisce separatamente su ogni membro, quindi unisce i risultati.
Questa è la base di Exclude, Extract e di molte utility.
type ToArray<T> = T extends unknown ? T[] : never;
type A = ToArray<string | number>;
// string[] | number[] (NOT (string | number)[])Cosa significa «nudo»
«Nudo» significa che il parametro di tipo compare da solo a sinistra di extends, senza essere racchiuso in un altro tipo. La distribuzione avviene solo per i parametri nudi.
type Naked<T> = T extends string ? "y" : "n";
// T is naked -> distributes over unionsLa distribuzione passo dopo passo
Per ToArray<string | number> il compilatore valuta ogni membro:
ToArray<string>= string[]ToArray<number>= number[]
Quindi li unisce: string[] | number[].
type R = ToArray<boolean>;
// boolean is true | false, so:
// true[] | false[]Filtrare un'unione
La distribuzione semplifica il filtraggio. Mappi i membri indesiderati a never; never scompare dall'unione, lasciando solo i membri conservati.
type Strings<T> = T extends string ? T : never;
type A = Strings<string | number | boolean>; // stringnever scompare nelle unioni
Un fatto fondamentale: X | never si semplifica in X. Quindi, quando un ramo distribuito produce never, quel membro viene di fatto rimosso dall'unione finale.
type A = string | never; // string
type B = "a" | never | "b"; // "a" | "b"Disabilitare la distribuzione
A volte non si desidera la distribuzione, ad esempio quando si confronta un'intera unione come un'unica entità. Racchiuda entrambi i lati in una tupla con un solo elemento: [T] extends [U]. Ora T non è più nudo, quindi la distribuzione è disattivata.
type IsNever<T> = [T] extends [never] ? true : false;
type A = IsNever<never>; // true
type B = IsNever<string>; // falsePerché il wrapping funziona
Inserendo [T] a sinistra, il tipo verificato è una tupla, non il parametro nudo. La regola speciale della distribuzione non si applica più, quindi l'unione viene verificata nel suo insieme.
type AllStrings<T> = [T] extends [string] ? true : false;
type A = AllStrings<"a" | "b">; // true
type B = AllStrings<"a" | number>; // falseDistribuito e non distribuito
Confronti direttamente le due forme. La versione nuda verifica ogni membro; la versione racchiusa verifica l'unione come un unico tipo.
type Distributed<T> = T extends string ? true : false;
type Wrapped<T> = [T] extends [string] ? true : false;
type A = Distributed<string | number>; // boolean (true | false)
type B = Wrapped<string | number>; // falseInterno di Exclude
L'integrato Exclude<T, U> rimuove da T ogni membro assegnabile a U. È semplicemente un condizionale distributivo che mappa i membri corrispondenti a never.
type MyExclude<T, U> = T extends U ? never : T;
type A = MyExclude<"a" | "b" | "c", "b">; // "a" | "c"Interno di Extract
Extract<T, U> è l'immagine speculare: conserva solo i membri assegnabili a U. La distribuzione è la stessa, ma i rami sono opposti.
type MyExtract<T, U> = T extends U ? T : never;
type A = MyExtract<"a" | "b" | "c", "a" | "c">; // "a" | "c"Potenza pratica
La distribuzione consente di trasformare ogni membro di un'unione in un'unica espressione: costruire array di ciascun membro, aggiungere un prefisso a ogni stringa o filtrare in base alla struttura. In combinazione con [T] extends [U] per i controlli sull'intera unione, permette di controllare esattamente quando si attiva la distribuzione.
Notazione: TypeScript reale scrive i tipi letterali template con stringhe delimitate da backtick che contengono segnaposto dollaro-graffe. In questi frammenti mostriamo questo schema come Tpl<...>, elencando ogni parte nell'ordine; ad esempio, un template con backtick che corrisponde al prefisso letterale seguito da Rest appare come Tpl<'prefix', infer Rest>.
type Prefix<T extends string> = T extends unknown ? Tpl<'id_', T> : never;
// Tpl<'id_', T> is the template literal type joining 'id_' with each T
type A = Prefix<'a' | 'b'>; // 'id_a' | 'id_b'Verifica rapida
Metta alla prova la Sua comprensione dei condizionali distributivi.
Riepilogo
I tipi condizionali distributivi sono il motore delle utility per le unioni.
- Un
T extends U ?nudo si distribuisce su ogni membro dell'unione. - I rami che restituiscono
neverfiltrano i membri. [T] extends [U]disabilita la distribuzione nei controlli sull'intera unione.ExcludeedExtractsono piccoli condizionali distributivi.
Il prossimo è il corso 22: l'aritmetica nel sistema dei tipi.
Domande Frequenti
La lezione «Tipi condizionali distributivi» è gratuita?
Sì — il testo completo di «Tipi condizionali distributivi» è 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 «Tipi condizionali distributivi»?
Controlli come i condizionali vengono distribuiti sulle union. 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 «Tipi condizionali distributivi»?
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
- I tipi come linguaggio di calcolo
- Condizionali a livello di tipo
- Ricorsione a livello di tipo
- Tipi condizionali distributivi