O que são Generics no TypeScript: Reutilização e Abstração com Segurança de Tipos
Bem-vindo ao Módulo 4: Generics e Tipos Avançados e parabéns por atingir a marca monumental de 50% do curso completo! Nesta aula, você aprenderá o recurso mais transformador e poderoso para a criação de componentes, utilitários e bibliotecas reutilizáveis: os Generics no TypeScript.
📑 Índice do Conteúdo
1. O Problema Fundamental: Duplicação vs Perda de Segurança
Considere uma função simples que precisa retornar o primeiro elemento de um array. Sem tipos genéricos, como você implementaria essa rotina?
// ❌ ABORDAGEM 1: Duplicação de código para cada tipo primitivo
function primeiroNumero(arr: number[]): number | undefined {
return arr[0];
}
function primeiraString(arr: string[]): string | undefined {
return arr[0];
}
// ❌ ABORDAGEM 2: Usando "any" (Destruição da segurança de tipos)
function primeiroAny(arr: any[]): any {
return arr[0];
}
const item = primeiroAny(["Web-ZoneWare", "Academy"]);
// "item" é "any"! Você perdeu o autocompletar e o IntelliSense não ajuda mais!
item.metodoQueNaoExiste(); // Não dá erro em tempo de compilação, mas quebra em runtime!
A abordagem 1 viola o princípio DRY (Don’t Repeat Yourself) e é impossível de manter. A abordagem 2 apaga o TypeScript, abrindo as portas para bugs de runtime. É exatamente para preencher essa lacuna de abstração com segurança que surgem os Generics.
2. O Que São Generics: Variáveis de Tipo
Assim como funções normais aceitam argumentos que contêm valores, uma função genérica aceita argumentos que contêm tipos. Os Generics permitem capturar o tipo que o chamador passou, armazená-lo em uma Variável de Tipo (Type Parameter) — por convenção batizada de <T> — e reutilizá-la nos parâmetros e no retorno:
// ✅ ABORDAGEM ELEGANTE COM GENERICS:
function primeiroItem<T>(arr: T[]): T | undefined {
return arr[0];
}
// 1. Passando o tipo explicitamente:
const nome = primeiroItem<string>(["Carlos", "Mariana"]); // Tipo inferido: string | undefined
// 2. Com inferência automática de tipo (Type Argument Inference):
// O compilador inspeciona [10, 20, 30] e descobre sozinho que T é "number"!
const numero = primeiroItem([10, 20, 30]); // Tipo inferido: number | undefined
// O IntelliSense funciona perfeitamente:
if (nome) {
console.log(nome.toUpperCase()); // Métodos nativos de string liberados!
}
3. A Função Identity (O Exemplo Clássico)
O exemplo clássico da literatura de ciência da computação para entender a preservação de tipo é a função Identity (Identidade), que simplesmente devolve exatamente o mesmo valor que recebe:
function identidade<T>(argumento: T): T {
return argumento;
}
const texto = identidade("TypeScript"); // Tipo: ___WZW_STR_1___ (ou string)
const contador = identidade(42); // Tipo: number
const usuario = identidade({ id: 1, ativo: true }); // Tipo: { id: number; ativo: boolean }
4. Generics vs. any vs. unknown: A Diferença Vital
| Recurso | Preserva Contrato de Entrada/Saída? | Segurança de Tipos | IntelliSense / Autocomplete |
|---|---|---|---|
any |
❌ Não (Retorna any) | Nenhuma (Desliga o compilador) | ❌ Perdido |
unknown |
❌ Não (Exige type narrowing) | Alta (Obriga verificações) | ❌ Bloqueado até estreitar |
Generics (<T>) |
✅ Sim (Totalmente preservado) | Máxima (Segurança estática nativa) | ✅ 100% Funcional e Preciso |
5. Interfaces e DTOs Genéricos no Mundo Real
Onde os Generics brilham mais intensamente no dia a dia é na modelagem de Respostas de APIs e DTOs (Data Transfer Objects). Praticamente todas as APIs REST ou GraphQL corporativas possuem um envelope padronizado de metadados ao redor do payload de negócio:
// Envelope Padrão de Resposta de API Genérico:
interface RespostaServidor<TDados> {
sucesso: boolean;
dados: TDados;
mensagem?: string;
timestamp: string;
}
// Modelos de Domínio Específicos:
interface Aluno {
matricula: string;
nome: string;
curso: string;
}
interface Certificado {
codigoValidacao: string;
horasConcluidas: number;
emitidoEm: Date;
}
// Reutilização da mesma interface envelope com tipos distintos:
const respostaAluno: RespostaServidor<Aluno> = {
sucesso: true,
dados: {
matricula: "MAT-2026-99",
nome: "Beatriz Santos",
curso: "TypeScript Profissional"
},
timestamp: new Date().toISOString()
};
const respostaCertificados: RespostaServidor<Certificado[]> = {
sucesso: true,
dados: [
{
codigoValidacao: "CERT-XYZ-77",
horasConcluidas: 60,
emitidoEm: new Date()
}
],
timestamp: new Date().toISOString()
};
// O compilador sabe que respostaAluno.dados possui .matricula:
console.log("Matrícula:", respostaAluno.dados.matricula);
// E sabe que respostaCertificados.dados é um ARRAY:
console.log("Total de certificados:", respostaCertificados.dados.length);
6. Convenções de Nomenclatura da Comunidade
T(Type): A letra padrão utilizada quando há apenas um único parâmetro genérico.U,V: Letras subsequentes no alfabeto quando uma função recebe múltiplos parâmetros genéricos secundários.K(Key) eV(Value): Utilizados em estruturas de dados associativas, dicionários e mapas chave-valor.E(Element): Tradicionalmente usado em coleções, listas e arrays.- Nomes Descritivos com Prefixo T (ex:
TDados,TPayload): Altamente recomendados em projetos corporativos quando as funções lidam com múltiplos genéricos complexos.
Aplique o que você aprendeu nesta lição
Utilize nossas ferramentas online gratuitas para experimentar os conceitos ou teste o código ao vivo no Playground IDE.
Editor de Códigos Web Online
Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.
Abrir Ferramenta OnlinePlayground Web Online
Escreva seu código HTML, CSS ou JavaScript e veja o resultado renderizado ao vivo no navegador com zero configuração.
⚡ Codificar no Playground IDE