0Pricing
TypeScript Academy · Lezione

Pluralizzazione con i tipi

Modelli le forme plurali in modo type-safe.

Pluralizzazione con i tipi è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Pluralizzazione con sicurezza dei tipi

Le lingue hanno bisogno di forme plurali: "1 elemento" rispetto a "2 elementi". L'i18n con sicurezza dei tipi modella le categorie di pluralizzazione (come one / other) e richiede un argomento count, così non lo si dimentica mai.

Categorie di pluralizzazione

Le regole di pluralizzazione di Intl definiscono categorie come zero, one, two, few, many, other. L'inglese usa solo one e other; altre impostazioni locali ne usano di più.

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

Struttura di un messaggio plurale

Si rappresenti un messaggio con pluralizzazione come un oggetto indicizzato per categoria. other è il fallback obbligatorio.

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

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

Distinguere tra plurale e semplice

Un catalogo combina stringhe semplici e oggetti plurali. I requisiti degli argomenti sono diversi, quindi rileviamo la struttura a livello di tipo.

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

Richiedere count

Quando un messaggio è plurale, gli argomenti della funzione di traduzione devono includere un count numerico. Calcoliamo il tipo degli argomenti in modo condizionale.

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

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

Un t tipizzato per i plurali

Si combini la ricerca nel catalogo con gli argomenti condizionali, in modo che i messaggi plurali richiedano count e quelli semplici no.

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

Selezionare la forma a runtime

A runtime, Intl.PluralRules sceglie la categoria in base al conteggio e si legge la stringa corrispondente, ricorrendo a other come fallback.

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);
}

Combinare con l'interpolazione

Le stringhe plurali contengono spesso anche {count}. Il tipo degli argomenti può intersecare i requisiti del plurale con le variabili di interpolazione estratte dalla forma scelta.

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

Impostazioni locali con forme più ricche

Alcune impostazioni locali, ad esempio il polacco e il russo, usano few e many. Poiché PluralCategory li include già, un catalogo può fornire queste chiavi e lo stesso meccanismo le gestisce.

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

Imporre il fallback other

Poiché other è obbligatorio in PluralMessage, il sistema dei tipi garantisce l'esistenza di un fallback, evitando il caso a runtime in cui nessuna forma plurale corrisponde.

Perché è importante

Gli errori di pluralizzazione ("1 elementi") e i conteggi dimenticati sono comuni nell'i18n senza tipizzazione. Modellare le categorie come tipi e richiedere count rende la pluralizzazione corretta il comportamento predefinito e trasforma l'assenza del conteggio in un errore di compilazione.

Verifica rapida

Verifichi la Sua comprensione della pluralizzazione con sicurezza dei tipi.

Riepilogo

Ha modellato i plurali come oggetti indicizzati per categorie di pluralizzazione, con un fallback other obbligatorio, ha rilevato i messaggi plurali a livello di tipo e ha richiesto un argomento count numerico tramite tipi condizionali. Intl.PluralRules seleziona la forma a runtime e lo stesso meccanismo si adatta alle impostazioni locali con forme più ricche.

Domande Frequenti

La lezione «Pluralizzazione con i tipi» è gratuita?

Sì — il testo completo di «Pluralizzazione con i 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 «Pluralizzazione con i tipi»?

Modelli le forme plurali in modo type-safe. 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 3 di 4.

Quanto tempo richiede la lezione «Pluralizzazione con i 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

  1. Tipizzare le chiavi di traduzione
  2. Type safety dell’interpolazione
  3. Pluralizzazione con i tipi
  4. Inferenza dei tipi consapevole della locale
← Torna a TypeScript Academy