Pluralização com Tipos
Modele formas plurais de maneira segura quanto aos tipos.
Pluralização com Tipos é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.
Pluralização com segurança de tipos
Os idiomas precisam de formas de plural: "1 item" versus "2 itens". A i18n com segurança de tipos modela categorias de plural (como one / other) e exige um argumento count, para que você nunca se esqueça dele.
Categorias de plural
As regras de pluralização de Intl definem categorias como zero, one, two, few, many, other. O inglês usa apenas one e other; outras localidades usam mais categorias.
type PluralCategory = "zero" | "one" | "two" | "few" | "many" | "other";Estrutura de uma mensagem de plural
Represente uma mensagem de plural como um objeto cujas chaves são categorias. other é a alternativa obrigatória.
type PluralMessage = {
other: string;
} & Partial<Record<Exclude<PluralCategory, "other">, string>>;
const items: PluralMessage = {
one: "{count} item",
other: "{count} items",
};Distinguindo mensagens de plural das simples
Um catálogo combina mensagens de texto simples e objetos de plural. Os requisitos de argumentos diferem, então detectamos a estrutura em nível de tipos.
type IsPlural<M> = M extends { other: string } ? true : false;Exigindo count
Quando uma mensagem é de plural, os argumentos de tradução devem incluir um count numérico. Calculamos o tipo dos argumentos condicionalmente.
type PluralArgs<M> = IsPlural<M> extends true
? { count: number }
: {};
type A = PluralArgs<typeof items>; // { count: number }Uma função t tipada para plurais
Combine a consulta ao catálogo com os argumentos condicionais para que as mensagens de plural exijam count e as simples não.
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", {}); // okSelecionando a forma em tempo de execução
Em tempo de execução, Intl.PluralRules escolhe a categoria a partir da contagem, e você lê a cadeia de caracteres correspondente (usando other como alternativa).
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);
}Combinando com interpolação
As cadeias de caracteres de plural geralmente também contêm {count}. O tipo dos argumentos pode combinar os requisitos do plural com as variáveis de interpolação extraídas da forma escolhida.
type FullArgs<M> = PluralArgs<M> & ExtractVars<M>;
// count plus any {placeholders} in the messageLocalidades com formas mais ricas
Algumas localidades (por exemplo, a polonesa e a russa) usam few e many. Como PluralCategory já as inclui, um catálogo pode fornecer essas chaves e o mesmo mecanismo cuidará delas.
const ruItems = {
one: "{count} товар",
few: "{count} товара",
many: "{count} товаров",
other: "{count} товара",
};Exigindo a alternativa other
Como other é obrigatório em PluralMessage, o sistema de tipos garante que exista uma alternativa, evitando um caso em tempo de execução em que nenhuma forma de plural corresponda.
Por que isso importa
Erros de plural ("1 itens") e contagens esquecidas são comuns em i18n sem tipos. Modelar categorias como tipos e exigir count faz da pluralização correta o padrão e transforma a ausência de uma contagem em um erro de compilação.
Verificação rápida
Verifique sua compreensão da pluralização com segurança de tipos.
Recapitulação
Você modelou os plurais como objetos cujas chaves são categorias de plural, com uma alternativa other obrigatória, detectou mensagens de plural em nível de tipos e exigiu um argumento count numérico por meio de tipos condicionais. Intl.PluralRules seleciona a forma em tempo de execução, e o mesmo mecanismo se adapta a localidades com formas mais ricas.
Perguntas Frequentes
A aula “Pluralização com Tipos” é grátis?
Sim — o texto completo de “Pluralização com Tipos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.
O que vou aprender em “Pluralização com Tipos”?
Modele formas plurais de maneira segura quanto aos tipos. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar TypeScript Academy?
Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Pluralização com Tipos”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de TypeScript Academy?
Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Definindo Tipos para Chaves de Tradução
- Segurança de Tipos na Interpolação
- Pluralização com Tipos
- Inferência de Tipos Sensível à Localidade