TypeScript Academy · Lektion

Definiera typkonstruktorer

Koda typkonstruktorer som interface-uppslag.

Lektion 2 av 413 steg

Definiera typkonstruktorer är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Namnge typkonstruktorer

Kodningen börjar med att varje typkonstruktor får en unik strängidentifierare som kallas URI. URI:n är en tagg som representerar konstruktorn på de ställen där vi inte kan skicka själva konstruktorn.

type ArrayURI = "Array";
type OptionURI = "Option";
// Each container gets a unique string tag

Ett registergränssnitt

Vi använder ett enda gränssnitt som mappar varje URI till den konkreta typ som den producerar för ett givet argument A. Detta gränssnitt är registret. Varje nyckel är en URI och varje värde är den upplösta typen.

interface URItoKind<A> {
  Array: Array<A>;
  Option: A | null;
}
// URItoKind<number>["Array"] is number[]

Slå upp en konstruktor

Eftersom registret är indexerat med URI:er blir tillämpningen av en konstruktor en indexerad åtkomst. För att få "Array tillämpad på number" indexerar ni registret.

type ArrayOfNumber = URItoKind<number>["Array"]; // number[]
type OptionOfString = URItoKind<string>["Option"]; // string | null

URIS-unionen

Mängden giltiga konstruktortaggar är helt enkelt registrets nycklar. keyof URItoKind<unknown> ger unionen av alla registrerade URI:er, och den kallar vi URIS.

type URIS = keyof URItoKind<unknown>; // "Array" | "Option"

Deklarationssammanslagning utökar registret

TypeScript har en kraftfull funktion: gränssnitt med samma namn slås samman. Bibliotek använder detta så att varje modul kan lägga till sin egen behållare i URItoKind utan att redigera den ursprungliga definitionen.

interface URItoKind<A> {
  Tree: { value: A; children: Array<A> };
}
// Now URIS also includes "Tree"

Modulära behållare

Tack vare sammanslagningen registrerar en behållare som definieras i en fil sig globalt. Alla som importerar den kan använda dess URI i generiska abstraktioner. Det är precis så fp-ts lägger till Option, Either, Task med flera.

// file a.ts
interface URItoKind<A> { Either: { left: A } | { right: A } }
// file b.ts can now reference the "Either" URI

En fantombärare

För att kunna skicka runt "vilken konstruktor" som en typ på värdenivå innehåller instanserna sin URI i en egenskap, ofta ett fantomfält. Fältet innehåller aldrig ett verkligt värde; det registrerar bara taggen för typsystemet.

interface HasURI<F extends URIS> {
  readonly _URI: F;
}
// _URI records which constructor an instance is for

Koppla URI till argument

En konstruktorstillämpning behöver två saker: URI:n F och argumenttypen A. Vi kombinerar dem med ett uppslag, så att (F, A) via registret kan lösas upp till den konkreta typen.

type Apply<F extends URIS, A> = URItoKind<A>[F];

type A = Apply<"Array", number>;  // number[]
type B = Apply<"Option", string>; // string | null

Varför strängar, inte konstruktorer

Vi använder strängar eftersom TypeScript kan lagra och jämföra dem som literaltyper och indexera ett register med dem. Vi kan inte lagra konstruktorn Array som en typparameter, men vi kan lagra literalen "Array" och slå upp den.

type Tag = "Array";
type Resolved = URItoKind<boolean>[Tag]; // boolean[]

Uppslagningen är det avgörande steget

Denna indexerade åtkomst, URItoKind<A>[F], är kärnan i kodningen. Den omvandlar den omöjliga typappliceringen F<A> till en giltig registeruppslagning. Nästa lektion formaliserar den som Kind<F, A>.

type Kind<F extends URIS, A> = URItoKind<A>[F];

type X = Kind<"Array", number>; // number[]

Sammanfattning av grunderna

Nu har ni alla delar: URI:er som taggar, ett URItoKind-register som mappar tagg plus argument till en konkret typ, URIS som unionen av taggar och deklarationssammanslagning för att utöka registret. Genom att indexera registret simuleras typapplicering.

// URItoKind = registry, URIS = valid tags,
// URItoKind<A>[F] = "apply constructor F to A"

Snabbkontroll

Testa er förståelse av registerkodningen.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er att koda typkonstruktorer med strängar.

Varje konstruktor får en unik URI-tagg.
URItoKind<A> mappar taggar till konkreta typer.
URIS är unionen av alla taggar via keyof.
Deklarationssammanslagning gör det möjligt för moduler att registrera nya behållare.

Nästa steg: paketera uppslagningen som det lättviktiga Kind-mönstret.

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 101
Lektioner: 352

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Definiera typkonstruktorer” gratis?

Ja – hela texten till ”Definiera typkonstruktorer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Definiera typkonstruktorer”?

Koda typkonstruktorer som interface-uppslag. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?

Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Definiera typkonstruktorer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?

Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till TypeScript Academy