Frontend Academy · Lektion

Skabelonliteral-typer

Kombiner string literal-typer med skabelonliteral-syntaks for at udlede typer som hændelsesnavne, CSS-egenskabsstrenge og API-rutestier.

Lektion 1 af 413 trin

Skabelonliteral-typer er en gratis Frontend Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Frontend Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Frontend Academy-kurset indeholder 4 lektioner i alt.

Hvad er skabelonliteraltyper?

TypeScript kan opbygge strengtyper fra skabelonliterals på typeniveau. Kombineret med uniontyper kan du udtrykke tusindvis af gyldige strenge uden at opliste dem enkeltvis.

Grundlæggende skabelonliteraltype

Brug strenge omgivet af backticks på typepositionen — de accepterer andre typer som interpolationer.

type Greeting = `Hello, ${string}!`;
const a: Greeting = 'Hello, Alice!';  // OK
const b: Greeting = 'Hi, Alice!';     // Error

Kombination af unioner

Når du interpolerer en union, opretter TypeScript krydsproduktet af alle kombinationer.

type Direction = 'top' | 'right' | 'bottom' | 'left';
type Property = 'margin' | 'padding';

type Side = `${Property}-${Direction}`;
// 'margin-top' | 'margin-right' | ... | 'padding-left' (8 strings)

Inferens af hændelsesnavne

Udled navne på hændelsesbehandlere fra hændelsesnavne — en klassisk anvendelse fra virkeligheden.

type EventName = 'click' | 'focus' | 'blur' | 'change';
type HandlerName = `on${Capitalize<EventName>}`;
// 'onClick' | 'onFocus' | 'onBlur' | 'onChange'

type Handlers = { [K in HandlerName]?: (e: Event) => void };
// { onClick?: ...; onFocus?: ...; onBlur?: ...; onChange?: ... }

Hjælpeværktøjstyper til strengmanipulation

TypeScript leveres med indbyggede hjælpere: Uppercase<T>, Lowercase<T>, Capitalize<T>, Uncapitalize<T>.

type Hi = Capitalize<'hello'>;    // 'Hello'
type Yell = Uppercase<'hello'>;   // 'HELLO'
type Quiet = Lowercase<'HELLO'>;  // 'hello'
type Lower = Uncapitalize<'Hi'>;  // 'hi'

CSS-egenskabstyper

Udtryk CSS-lignende strengtyper: pixelværdier, hex-farver og procentværdier.

type Px = `${number}px`;
type Hex = `#${string}`;
type Pct = `${number}%`;

type Style = { padding: Px; color: Hex; width: Pct };

const s: Style = { padding: '8px', color: '#fff', width: '50%' }; // OK
const bad: Style = { padding: '8', color: 'white', width: '50' }; // Error

Inferens med skabelonliterals

Nøgleordet infer kan udtrække dele af en strengtype — nyttigt til parsere og rutetyper.

type ExtractName<T> = T extends `Hello, ${infer Name}!` ? Name : never;

type Result = ExtractName<'Hello, Alice!'>;  // 'Alice'

Typer til API-ruter

Typesikre API-ruter: udtræk sti-parametre fra et strengmønster.

type PathParams<T extends string> =
  T extends `${string}/:${infer Param}/${infer Rest}`
    ? { [K in Param | keyof PathParams<`/${Rest}`>]: string }
    : T extends `${string}/:${infer Param}`
    ? { [K in Param]: string }
    : {};

type P = PathParams<'/users/:userId/posts/:postId'>;
// { userId: string; postId: string }

Forslagstyper til Tailwind-klasser

Begræns strengegenskaber til kendte værdier fra designsystemet.

type Spacing = 0 | 1 | 2 | 4 | 8 | 16;
type Side = 't' | 'r' | 'b' | 'l';
type TwSpacing = `m${Side}-${Spacing}` | `p${Side}-${Spacing}`;
// 'mt-0' | 'mt-1' | ... | 'pl-16'

function Box(props: { className: TwSpacing }) { /* ... */ }

Begrænsninger og compilerens ydeevne

Krydsprodukter af skabelonliterals kan eksplodere (en union på 50 × 50 giver 2500 strenge). TypeScript kompilerer stadig, men inferensen bliver langsom. Hold alfabetet lille.

Skelnen mellem strengliteraltyper

Brug skabelonliterals som en mere udtryksfuld form for typemarkering — stadig en streng, men med begrænsninger.

Hurtigt tjek

Hvad evalueres type X = `on${Capitalize<'click' | 'focus'>}` til?

Opsummering: Skabelonliteraltyper

Opbyg strengtyper fra skabelonliterals med interpolerede unioner. Krydsprodukter vokser hurtigt — hold alfabetet lille. Brug Capitalize/Uppercase/Lowercase/Uncapitalize. Kombiner med infer for at udtrække dele af strenge. Det er velegnet til hændelsesnavne, CSS-værdier, ruteparametre og klassenavne fra designsystemer.

Gratis at komme i gang

Lær HTML med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
41
Lektioner
163

Ofte stillede spørgsmål

Er lektionen “Skabelonliteral-typer” gratis?

Ja — hele teksten til “Skabelonliteral-typer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Frontend Academy-kurset, skal du opgradere til CoddyKit PRO. Frontend Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Skabelonliteral-typer”?

Kombiner string literal-typer med skabelonliteral-syntaks for at udlede typer som hændelsesnavne, CSS-egenskabsstrenge og API-rutestier. Du øver dig i Frontend Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Frontend Academy?

Der kræves ingen tidligere erfaring. Frontend Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Skabelonliteral-typer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Frontend Academy-lektion?

Ja. Alle Frontend Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Skabelonliteral-typer
  2. Dekoratorer og metadata
  3. TypeScript med React: FC-generics og hooks
  4. Strict Mode og eliminering af any
← Tilbage til Frontend Academy