TypeScript Academy · Lektion

Pluralisering med typer

Modellera pluralformer på ett typsäkert sätt.

Lektion 3 av 413 steg

Pluralisering med typer är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 3 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.

Typsäker pluralisering

Språk behöver pluralformer: "1 vara" jämfört med "2 varor". Typsäker i18n modellerar pluraliseringskategorier (som one / other) och kräver ett count-argument, så att det aldrig glöms bort.

Pluraliseringskategorier

Intl:s pluralregler definierar kategorier som zero, one, two, few, many och other. Engelska använder bara one och other; andra locales använder fler.

type PluralCategory = "zero" | "one" | "two" | "few" | "many" | "other";

En pluraliserad meddelandestruktur

Representera ett pluraliserat meddelande som ett objekt med kategorin som nyckel. other är den obligatoriska fallbacken.

type PluralMessage = {
  other: string;
} & Partial<Record<Exclude<PluralCategory, "other">, string>>;

const items: PluralMessage = {
  one: "{count} item",
  other: "{count} items",
};

Skilja mellan pluraliserade och vanliga meddelanden

En katalog innehåller både vanliga strängar och pluralobjekt. Kraven på argument skiljer sig åt, så strukturen identifieras på typnivå.

type IsPlural<M> = M extends { other: string } ? true : false;

Kräva count

När ett meddelande är pluraliserat måste translate-argumenten innehålla ett numeriskt count. Argumenttypen beräknas villkorligt.

type PluralArgs<M> = IsPlural<M> extends true
  ? { count: number }
  : {};

type A = PluralArgs<typeof items>; // { count: number }

Ett typat t för pluralformer

Kombinera kataloguppslagningen med villkorliga argument, så att pluraliserade meddelanden kräver count medan vanliga meddelanden inte gör det.

declare const cat: {
  items: { one: string; other: string };
  hello: string;
};

declare function t<K extends keyof typeof cat>(
  key: K,
  args: PluralArgs<(typeof cat)[K]>
): string;

t("items", { count: 3 }); // ok
t("items", {});           // Error: count required
t("hello", {});           // ok

Välja form vid körning

Vid körning väljer Intl.PluralRules kategori utifrån count, och den matchande strängen läses av (med fallback till other).

function plural(msg: { other: string; [k: string]: string }, count: number, locale: string) {
  const cat = new Intl.PluralRules(locale).select(count);
  return (msg[cat] ?? msg.other);
}

Kombinera med interpolering

Pluraliserade strängar innehåller vanligtvis även {count}. Argumenttypen kan kombinerar pluraliseringskraven med extraherade interpoleringsvariabler från den valda formen.

type FullArgs<M> = PluralArgs<M> & ExtractVars<M>;
// count plus any {placeholders} in the message

Locales med fler former

Vissa locales (t.ex. polska och ryska) använder few och many. Eftersom PluralCategory redan innehåller dem kan en katalog tillhandahålla dessa nycklar, och samma mekanism hanterar dem.

const ruItems = {
  one: "{count} товар",
  few: "{count} товара",
  many: "{count} товаров",
  other: "{count} товара",
};

Säkerställa fallbacken other

Eftersom other är obligatoriskt i PluralMessage garanterar typsystemet att en fallback finns, vilket förhindrar att ingen pluralform matchar vid körning.

Varför detta är viktigt

Pluraliseringsfel ("1 items") och bortglömda count-värden är vanliga i otypad i18n. Genom att modellera kategorier som typer och kräva count blir korrekt pluralisering standard, medan ett saknat count blir ett kompileringsfel.

Snabbtest

Kontrollera förståelsen av typsäker pluralisering.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Pluralisering modellerades som objekt med pluraliseringskategorier som nycklar och en obligatorisk fallback med other. Pluraliserade meddelanden identifierades på typnivå, och ett numeriskt count-argument krävdes med hjälp av villkorliga typer. Intl.PluralRules väljer formen vid körning, och samma mekanism kan hantera locales med fler former.

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 ”Pluralisering med typer” gratis?

Ja – hela texten till ”Pluralisering med typer” 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 ”Pluralisering med typer”?

Modellera pluralformer på ett typsäkert sätt. 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 3 av 4.

Hur lång tid tar lektionen ”Pluralisering med typer”?

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