Generics em JavaScript: para que servem e como usar

Generics em JavaScript: para que servem e como usar

O desenvolvimento moderno em JavaScript e Node.js exige não apenas a escrita rápida de código, mas também sua confiabilidade. Uma das ferramentas-chave que garantem flexibilidade e segurança de tipos são os generics. Neste artigo, vamos entender o que são generics, por que são necessários no ecossistema JavaScript e como aplicá-los eficazmente na prática. O material será útil tanto para iniciantes quanto para desenvolvedores experientes que desejam aprofundar seus conhecimentos.

O que são Generics e para que servem?

Generics (tipos genéricos) são um mecanismo que permite criar componentes (funções, classes, interfaces) que funcionam com diferentes tipos de dados, mantendo uma tipagem estrita. Ao contrário do JavaScript comum, que é dinamicamente tipado, os generics vêm do mundo do TypeScript — uma extensão do JS que adiciona tipagem estática.

Para que isso serve? Imagine que você está escrevendo uma função que retorna o primeiro elemento de um array. Sem generics, você teria que usar o tipo any, o que elimina as sugestões da IDE e aumenta o risco de erros. Com Generics, você pode escrever um código universal que funciona de forma segura com números, strings, objetos e qualquer outro tipo.

// Sem generics (perigoso)function getFirst(arr: any[]): any {  return arr[0];}

// Com generics (seguro)function getFirst<T>(arr: T[]): T | undefined {  return arr[0];}

const num = getFirst([1, 2, 3]); // tipo numberconst str = getFirst(['a', 'b']); // tipo string

Assim, os generics tornam o código mais reutilizável e type-safe, o que é especialmente importante em projetos grandes em Node.js.

Como usar Generics em TypeScript (JavaScript com tipos)

Embora o JavaScript puro não suporte generics, o TypeScript se integra completamente ao ecossistema Node.js. Vamos ver os principais cenários de uso.

1. Funções genéricas

A maneira mais simples é parametrizar uma função com um ou mais tipos. Isso é útil para utilitários que trabalham com coleções.

// Função para mesclar dois arraysfunction mergeArrays<T>(arr1: T[], arr2: T[]): T[] {  return [...arr1, ...arr2];}

const numbers = mergeArrays([1, 2], [3, 4]); // number[]const strings = mergeArrays(['hello'], ['world']); // string[]

Aqui, <T> é um parâmetro de tipo que é substituído automaticamente quando a função é chamada. Você também pode especificar o tipo explicitamente:

const mixed = mergeArrays<number | string>([1], ['a']); // (number | string)[]

2. Classes genéricas

Generics são ótimos para criar estruturas de dados, como pilhas, filas ou caches.

class Stack<T> {  private items: T[] = [];

  push(item: T): void {    this.items.push(item);  }

  pop(): T | undefined {    return this.items.pop();  }

  peek(): T | undefined {    return this.items[this.items.length - 1];  }}

// Usoconst numberStack = new Stack<number>();numberStack.push(10);numberStack.push(20);console.log(numberStack.pop()); // 20

const stringStack = new Stack<string>();stringStack.push('TypeScript');console.log(stringStack.peek()); // 'TypeScript'

3. Restrições de tipos (Constraints)

Às vezes, é necessário restringir o generic a um conjunto específico de tipos. Por exemplo, garantir que o objeto tenha uma propriedade length.

// Restringimos T a tipos que possuem lengthfunction logLength<T extends { length: number }>(item: T): void {  console.log(`Comprimento: ${item.length}`);}

logLength('Olá'); // 3logLength([1, 2, 3]); // 3// logLength(123); // Erro: number não tem length

A palavra-chave exten ```