TypeScript Academy · Lektion

Mappade typer: omforma objekttyper

Iterera över nycklar för att skapa nya typer

Lektion 1 av 413 steg

Mappade typer: omforma objekttyper är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 1 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.

Välkommen

Mappade typer itererar över nycklarna i en typ för att skapa nya typer med omvandlade egenskaper. De utgör grunden för Partial, Readonly, Record och många andra verktygstyper.

Grundläggande syntax för mappade typer

Använd `[K in keyof T]` för att iterera över alla nycklar i T och skapa en ny typ.
type Copy<T> = { [K in keyof T]: T[K] };
type UserCopy = Copy<User>; // same as User

Göra alla egenskaper valfria

Så här implementeras Partial – lägg till ? på varje egenskap.
type Partial<T> = { [K in keyof T]?: T[K] };
type PartialUser = Partial<User>;

Göra alla egenskaper skrivskyddade

Lägg till `readonly` för varje egenskap i den mappade typen.
type Readonly<T> = { readonly [K in keyof T]: T[K] };
type FrozenUser = Readonly<User>;

Omvandla värdetyper

Ändra värdetypen för varje egenskap samtidigt som nycklarna behålls.
type Stringify<T> = { [K in keyof T]: string };
type StringUser = Stringify<User>; // all values are string

Filtrera egenskaper med never

Använd ett villkor på värdepositionen och filtrera med never genom ommappning av nycklar.
type OnlyStrings<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K]
};

Record<K, V>

Record skapar en objekttyp med specifika nycklar och värdetyper.
type Record<K extends string | number | symbol, V> = { [P in K]: V };
const roles: Record<'admin' | 'user', boolean> = { admin: true, user: false };

Mappade typer bevarar valfrihet

Som standard bevarar mappade typer modifierarna för valfrihet och readonly från källtypen.
interface User { id: number; name?: string; }
type Copy<T> = { [K in keyof T]: T[K] };
type C = Copy<User>; // id: number; name?: string (preserved)

Ommappning av nycklar med as

Mappa om nycklar till nya namn genom att använda `as` i den mappade typen.
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};

Iterera över en union

Mappa över en unionstyp i stället för keyof T för att skapa objekttyper från unioner.
type Flags = { [K in 'option1' | 'option2' | 'option3']: boolean };

Kombinera mappade typer och villkorstyper

Mappade typer och villkorstyper kan kombineras naturligt för att skapa avancerade omvandlingar.
type NullableValues<T> = { [K in keyof T]: T[K] | null };

Snabbtest

Vad skapar `{ [K in keyof T]?: T[K] }`?

Sammanfattning

Mappade typer itererar över nycklar för att skapa nya typer. De kan lägga till eller ta bort readonly och ?, omvandla värdetyper, filtrera nycklar med never och mappa om nycklar med as. De ligger till grund för alla TypeScripts inbyggda verktygstyper.
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

Vanliga frågor

Är lektionen ”Mappade typer: omforma objekttyper” gratis?

Ja – hela texten till ”Mappade typer: omforma objekttyper” 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 ”Mappade typer: omforma objekttyper”?

Iterera över nycklar för att skapa nya typer 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 1 av 4.

Hur lång tid tar lektionen ”Mappade typer: omforma objekttyper”?

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

  1. Mappade typer: omforma objekttyper
  2. Modifierare i mappade typer: readonly och ?
  3. Mallitteraltyper: strängmönster
  4. Mappa om nycklar med as i mappade typer
← Tillbaka till TypeScript Academy