Classes e Interfaces Genéricas na Prática: Estruturas de Dados e Repositórios no TypeScript
Os Generics atingem seu ápice arquitetural quando aplicados à Programação Orientada a Objetos. Descubra como projetar Classes e Interfaces Genéricas no TypeScript para construir estruturas de dados robustas, camadas de cache e o consagrado Generic Repository Pattern adotado em sistemas corporativos.
📑 Índice do Conteúdo
1. O Conceito de Classes e Interfaces Genéricas
Até agora, aplicamos parâmetros de tipo no escopo de funções individuais. No entanto, muitas vezes precisamos que o estado interno de uma classe inteira ou que todos os métodos de um contrato operem sobre o mesmo tipo abstrato compartilhado.
A sintaxe é direta: declaramos os parâmetros genéricos logo após o nome da classe ou interface:
interface CaixaArmazenamento<T> {
guardar(item: T): void;
obter(): T | null;
}
2. Caso Prático 1: Estruturas de Dados Tipadas (Pilha / Stack)
Um exemplo clássico e elegante é a implementação de uma Pilha (Stack) que segue a política LIFO (Last-In, First-Out). A mesma classe pode ser reutilizada para armazenar números, comandos de histórico de desfazer (undo/redo) ou objetos de domínio:
class Pilha<T> {
private elementos: T[] = [];
// Adiciona um item ao topo da pilha:
empilhar(item: T): void {
this.elementos.push(item);
}
// Remove e retorna o item do topo:
desempilhar(): T | undefined {
return this.elementos.pop();
}
// Consulta o item do topo sem remover:
espiar(): T | undefined {
return this.elementos[this.elementos.length - 1];
}
obterTamanho(): number {
return this.elementos.length;
}
}
// 1. Pilha exclusiva de Histórico de Ações (Strings):
const historicoComandos = new Pilha<string>();
historicoComandos.empilhar("DIGITAR_TEXTO");
historicoComandos.empilhar("APLICAR_NEGRITO");
// O TypeScript garante que o item desempilhado é STRING:
const ultimoComando = historicoComandos.desempilhar();
console.log(ultimoComando?.toLowerCase()); // ___WZW_STR_0___
// ❌ Tentativa de empilhar número em pilha de string:
// historicoComandos.empilhar(123); // TS2345: Argument of type 'number' is not assignable to type 'string'.
3. Caso Prático 2: O Padrão Generic Repository (DDD / Clean Architecture)
Em aplicações empresariais com arquitetura limpa ou Domain-Driven Design (DDD), é padrão isolar o acesso a bancos de dados através de repositórios. Graças às interfaces genéricas, definimos um contrato universal de operações CRUD:
// Contrato Base Universal de Repositório:
interface IRepositorio<TEntidade, TId = string> {
buscarPorId(id: TId): Promise<TEntidade | null>;
salvar(entidade: TEntidade): Promise<void>;
excluir(id: TId): Promise<boolean>;
listarTodos(): Promise<TEntidade[]>;
}
// Entidade de Negócio:
interface UsuarioConta {
id: string;
nome: string;
email: string;
}
// Implementação em Memória Genérica com Restrição:
class RepositorioEmMemoria<TEntidade extends { id: TId }, TId = string>
implements IRepositorio<TEntidade, TId>
{
private tabela = new Map<TId, TEntidade>();
async buscarPorId(id: TId): Promise<TEntidade | null> {
return this.tabela.get(id) ?? null;
}
async salvar(entidade: TEntidade): Promise<void> {
this.tabela.set(entidade.id, entidade);
}
async excluir(id: TId): Promise<boolean> {
return this.tabela.delete(id);
}
async listarTodos(): Promise<TEntidade[]> {
return Array.from(this.tabela.values());
}
}
// Instanciando o repositório fortemente tipado para Usuários:
const repoUsuario = new RepositorioEmMemoria<UsuarioConta>();
await repoUsuario.salvar({ id: "usr_10", nome: "Mariana", email: "[email protected]" });
const user = await repoUsuario.buscarPorId("usr_10");
console.log("Usuário recuperado:", user?.nome); // Autocompletar total!
4. Herança e Extensão de Interfaces Genéricas
Uma interface genérica pode estender outra interface genérica, propagando ou transformando o tipo. Este padrão é amplamente utilizado em paginações de listas:
interface RespostaBase<T> {
sucesso: boolean;
dados: T;
}
// Estendendo e adicionando metadados de paginação ao array de T:
interface RespostaPaginada<TItem> extends RespostaBase<TItem[]> {
totalItens: number;
paginaAtual: number;
totalPaginas: number;
}
const resultadoAlunos: RespostaPaginada<string> = {
sucesso: true,
dados: ["Alice", "Bernardo", "Camila"], // Obrigatoriamente string[]
totalItens: 45,
paginaAtual: 1,
totalPaginas: 15
};
5. A Regra Estrita dos Membros Estáticos (static)
Uma classe no TypeScript possui dois lados em tempo de execução: o lado da instância (criado com new) e o lado estático (a própria função construtora). Por essa razão estrutural, membros estáticos NÃO podem referenciar o tipo genérico da classe:
class GerenciadorSessao<T> {
// ✅ Membro de Instância: Válido!
dadoSessao: T | null = null;
// ❌ ERRO DE COMPILAÇÃO:
// TS2302: Static members cannot reference class type arguments.
// static instanciaPadrao: T;
// ✅ Se um método estático precisar ser genérico, declare seu próprio tipo:
static criarVazio<U>(): GerenciadorSessao<U> {
return new GerenciadorSessao<U>();
}
}
IRepositorio<T, TId>, você desacopla completamente sua camada de regras de negócio (Controllers e Use Cases) de qualquer banco de dados específico (PostgreSQL, MongoDB, Prisma ou TypeORM), facilitando testes unitários com mocks em memória.
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