O que são Generics no TypeScript: Guia Completo
⚡ Curso de TypeScript • Web-ZoneWare

O que são Generics no TypeScript: Reutilização e Abstração com Segurança de Tipos

Lição 25 de 50

O que são Generics no TypeScript: Reutilização e Abstração com Segurança de Tipos

⚡ Módulo 4 • Aula 25 de 50 • Marco de 50% 🏆

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.

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?

typescript

JavaScript 17 linhas
// ❌ 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:

typescript

JavaScript 16 linhas
// ✅ 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:

typescript

JavaScript 7 linhas
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:

typescript

JavaScript 49 linhas
// 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) e V (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.
💡

Dica Pro de Engenharia Web-ZoneWare: Não force o uso de Generics onde uma união simples ou uma interface resolveria. Generics devem ser usados quando existe uma relação de dependência entre dois ou mais elementos (por exemplo: o tipo do retorno depende diretamente do tipo passado no parâmetro de entrada). Se a variável de tipo for declarada mas usada apenas em um único lugar, ela provavelmente é desnecessária.

🚀

Próximo Passo Prático: Agora que você compreendeu o papel das variáveis de tipo, na Lição 26 aprenderemos como combinar e correlacionar múltiplos tipos simultâneos: Funções Genéricas e Múltiplos Parâmetros de Tipo (<T, U, K>).

🛠️ Laboratório Prático & Prática Imediata

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.

💻 Desenvolvedor & Código

Editor de Códigos Web Online

Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.

Abrir Ferramenta Online
⚡ Live Code Studio

Playground 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
Foto de Web-Zoneware
✓ Verificado
🎓 Tutor & Coordenador da Web Academy

Web-Zoneware

Tutor Técnico & Desenvolvedor Full-Stack

Desenvolvedor web e instrutor focado na formação prática de novos programadores. Defensor ferrenho de código semântico, arquitetura limpa e acessibilidade W3C/WCAG, dedicando-se a construir cursos estruturados em metodologia passo a passo com execução ao vivo no Playground IDE.

Especialidades: HTML5 Semântico CSS3 & Flexbox/Grid JavaScript Moderno Acessibilidade WCAG 2.2 Didática Prática
Rolar para cima