Definire costruttori di tipi
Codifichi i costruttori di tipi come lookup nelle interfacce.
Definire costruttori di tipi è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 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.
Assegnare un nome ai costruttori di tipi
La codifica inizia assegnando a ogni costruttore di tipi un identificatore stringa univoco, chiamato URI. L'URI è un tag che rappresenta il costruttore nei punti in cui non possiamo passare direttamente il costruttore.
type ArrayURI = "Array";
type OptionURI = "Option";
// Each container gets a unique string tagUn'interfaccia di registro
Manteniamo un'unica interfaccia che associa ogni URI al tipo concreto prodotto per un dato argomento A. Questa interfaccia è il registro. Ogni chiave è un URI; ogni valore è il tipo risolto.
interface URItoKind<A> {
Array: Array<A>;
Option: A | null;
}
// URItoKind<number>["Array"] is number[]Cercare un costruttore
Poiché il registro è indicizzato tramite URI, l'applicazione di un costruttore diventa un accesso indicizzato. Per ottenere "Array applicato a number", si indicizza il registro.
type ArrayOfNumber = URItoKind<number>["Array"]; // number[]
type OptionOfString = URItoKind<string>["Option"]; // string | nullL'unione URIS
L'insieme dei tag validi dei costruttori è semplicemente l'insieme delle chiavi del registro. keyof URItoKind<unknown> restituisce l'unione di tutti gli URI registrati, che chiamiamo URIS.
type URIS = keyof URItoKind<unknown>; // "Array" | "Option"La fusione delle dichiarazioni estende il registro
Una potente funzionalità di TypeScript: le interfacce con lo stesso nome si fondono. Le librerie la usano per permettere a ogni modulo di aggiungere il proprio contenitore a URItoKind senza modificare la definizione originale.
interface URItoKind<A> {
Tree: { value: A; children: Array<A> };
}
// Now URIS also includes "Tree"Contenitori modulari
Grazie alla fusione, un contenitore definito in un file si registra globalmente. Chiunque lo importi può usare il suo URI nelle astrazioni generiche. È esattamente così che fp-ts aggiunge Option, Either, Task e altro.
// file a.ts
interface URItoKind<A> { Either: { left: A } | { right: A } }
// file b.ts can now reference the "Either" URIUn portatore fantasma
Per trasmettere a livello di tipo quale costruttore viene usato come se fosse un valore, le istanze contengono il proprio URI in una proprietà, spesso un campo fantasma. Il campo non contiene mai un valore reale; registra solo il tag per il sistema dei tipi.
interface HasURI<F extends URIS> {
readonly _URI: F;
}
// _URI records which constructor an instance is forAssociare l'URI all'argomento
L'applicazione di un costruttore richiede due elementi: l'URI F e il tipo dell'argomento A. Li combineremo tramite una ricerca, in modo che (F, A) venga risolto nel tipo concreto attraverso il registro.
type Apply<F extends URIS, A> = URItoKind<A>[F];
type A = Apply<"Array", number>; // number[]
type B = Apply<"Option", string>; // string | nullPerché stringhe e non costruttori
Usiamo le stringhe perché TypeScript può memorizzarle e confrontarle come tipi letterali e può indicizzare un registro con esse. Non possiamo memorizzare il costruttore Array come parametro di tipo, ma possiamo memorizzare il letterale "Array" e cercarlo.
type Tag = "Array";
type Resolved = URItoKind<boolean>[Tag]; // boolean[]La ricerca è il passaggio chiave
Questo accesso indicizzato, URItoKind<A>[F], è il cuore della codifica. Trasforma un'applicazione di tipo impossibile F<A> in una ricerca valida nel registro. La prossima lezione la formalizzerà come Kind<F, A>.
type Kind<F extends URIS, A> = URItoKind<A>[F];
type X = Kind<"Array", number>; // number[]Riepilogo della configurazione
Ora dispone dei vari elementi: gli URI come tag, un registro URItoKind che associa tag più argomento a un tipo concreto, URIS come unione dei tag e la fusione delle dichiarazioni per estenderlo. L'indicizzazione del registro simula l'applicazione di tipo.
// URItoKind = registry, URIS = valid tags,
// URItoKind<A>[F] = "apply constructor F to A"Verifica rapida
Verifichi la sua comprensione della codifica basata sul registro.
Riepilogo
Ha imparato a codificare i costruttori di tipi con le stringhe.
- Ogni costruttore riceve un tag URI univoco.
URItoKind<A>associa i tag ai tipi concreti.URISè l'unione di tutti i tag ottenuta tramitekeyof.- La fusione delle dichiarazioni consente ai moduli di registrare nuovi contenitori.
Prossimo argomento: racchiudere la ricerca nel modello leggero Kind.
Domande Frequenti
La lezione «Definire costruttori di tipi» è gratuita?
Sì — il testo completo di «Definire costruttori di tipi» è 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 «Definire costruttori di tipi»?
Codifichi i costruttori di tipi come lookup nelle interfacce. 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 2 di 4.
Quanto tempo richiede la lezione «Definire costruttori di tipi»?
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
- Il problema HKT in TypeScript
- Definire costruttori di tipi
- Il pattern HKT leggero
- Functor e mapper generici