Sobrecargas de funções e assinaturas de chamada
Declare assinaturas de sobrecarga para diferentes formatos de chamada e use assinaturas de chamada dentro de tipos de objetos para APIs flexíveis.
Sobrecargas de funções e assinaturas de chamada é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 de 3. 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 3 aulas no total.
Introdução
Objetivo: modelar funções que aceitam entradas diferentes e retornam saídas diferentes usando sobrecargas, além de descrever assinaturas de chamada em tipos de objeto para interfaces semelhantes a retornos de chamada.
Padrão de sobrecarga
Sobrecargas são declaradas como várias assinaturas, além de uma implementação que refina as entradas e retorna o tipo correto.
// 1) Overload signatures (no body)
function parse(input: string): number;
function parse(input: number): string;
// 2) Single implementation compatible with all overloads
function parse(input: string | number): string | number {
if (typeof input === "string") {
return input.length; // string -> number
} else {
return String(input); // number -> string
}
}
console.log(parse("TS")); // 2 (number)
console.log(parse(123)); // "123" (string)Assinaturas de chamada
Uma assinatura de chamada permite que um tipo de objeto possa ser chamado com sobrecargas, o que é útil para bibliotecas que expõem funções chamáveis com propriedades.
type Stringify = {
(v: number): string;
(v: boolean): string;
};
const toStr: Stringify = (v: number | boolean) => {
return typeof v === "number" ? v.toFixed(1) : (v ? "true" : "false");
};
console.log(toStr(3));
console.log(toStr(false));Refinamento na implementação
A implementação deve lidar com todos os formatos de sobrecarga. Use verificações com in ou uniões discriminadas para ramificar com segurança.
function area(value: { r: number } | { w: number; h: number }): number {
if ("r" in value) {
return Math.PI * value.r ** 2; // circle
}
return value.w * value.h; // rect
}
console.log(area({ r: 2 }));
console.log(area({ w: 3, h: 4 }));Sobrecargas versus uniões
Sobrecargas versus uniões:
- As sobrecargas fornecem tipos de retorno precisos por chamada.
- As uniões mantêm uma única assinatura, que é mais simples, mas menos específica.
- Escolha sobrecargas quando os chamadores se beneficiarem de tipos de retorno exatos.
Dicas de DX
Dicas:
- Mantenha a quantidade de sobrecargas pequena e clara.
- Documente as diferenças nos parâmetros e retornos.
- Prefira a precisão do tipo de retorno quando ela melhorar a experiência de uso.
Verificação de sobrecargas
Verificação rápida: qual padrão declara corretamente as sobrecargas de uma função?
Recapitulação
Recapitulação: use sobrecargas para obter tipos precisos por chamada e assinaturas de chamada para modelar objetos chamáveis. Faça o refinamento dentro da única implementação para abranger todos os casos.
Perguntas Frequentes
A aula “Sobrecargas de funções e assinaturas de chamada” é grátis?
Sim — o texto completo de “Sobrecargas de funções e assinaturas de chamada” é 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 3 aulas no total.
O que vou aprender em “Sobrecargas de funções e assinaturas de chamada”?
Declare assinaturas de sobrecarga para diferentes formatos de chamada e use assinaturas de chamada dentro de tipos de objetos para APIs flexíveis. 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 1 de 3.
Quanto tempo leva a aula “Sobrecargas de funções e assinaturas de chamada”?
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
- Sobrecargas de funções e assinaturas de chamada
- Tipagem do parâmetro this; void, never
- Funções de asserção e guardas de tipo definidos pelo usuário