Genéricos

Boas-vindas à próxima lição! Nesta lição, você aprenderá sobre genéricos, um recurso poderoso do TypeScript que permite criar componentes reutilizáveis e seguros quanto aos tipos. Vamos começar!

O que são genéricos?

Os genéricos permitem escrever código reutilizável que funciona com qualquer tipo. Eles atuam como espaços reservados para tipos que você pode especificar ao usá-los.

Exemplo: Uma função genérica:

Tarefa: Escreva uma função genérica que receba um argumento e o retorne sem alterações.

function identity<T>(value: T): T {
  return value;
}

console.log(identity<string>("Hello")); 
// Output: Hello
console.log(identity<number>(42)); 
// Output: 42

Por que usar genéricos?

Os genéricos ajudam você a:

• Escrever código reutilizável: Funções e classes podem trabalhar com diferentes tipos.
• Garantir a segurança de tipos: Você pode impor tipos específicos sem abrir mão da flexibilidade.
• Reduzir a redundância: Evite escrever versões separadas da mesma função ou classe para diferentes tipos.

Dica: Use genéricos para escrever código mais flexível e fácil de manter.

Funções genéricas

Você pode usar genéricos para criar funções flexíveis. Exemplo:

Tarefa: Escreva uma função genérica que combine dois objetos e retorne o resultado.

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

let merged = merge({ name: "Alice" }, { age: 25 });
console.log(merged); 
// Output: { name: "Alice", age: 25 }

Classes genéricas

Os genéricos podem ser usados em classes para torná-las reutilizáveis com diferentes tipos. Exemplo:

class Box<T> {
  private contents: T;

  constructor(contents: T) {
    this.contents = contents;
  }

  getContents(): T {
    return this.contents;
  }
}

let stringBox = new Box<string>("Hello");
console.log(stringBox.getContents()); 
// Output: Hello

let numberBox = new Box<number>(42);
console.log(numberBox.getContents()); 
// Output: 42

Interfaces genéricas

As interfaces também podem usar genéricos para impor uma estrutura a diferentes tipos. Exemplo:

Tarefa: Defina uma interface genérica e crie um objeto que a implemente.

interface Pair<T, U> {
  first: T;
  second: U;
}

let coordinates: Pair<number, number> = { first: 10, second: 20 };
console.log(coordinates); 
// Output: { first: 10, second: 20 }

Restrições de genéricos

Você pode adicionar restrições aos genéricos para garantir que eles funcionem apenas com tipos específicos. Exemplo:

function printLength<T extends { length: number }>(item: T): void {
  console.log(`Length: ${item.length}`);
}

printLength("Hello"); 
// Output: Length: 5
printLength([1, 2, 3]); 
// Output: Length: 3
// printLength(42); 
// Error: Argument of type 'number' is not assignable to parameter of type '{ length: number }'.

Valores padrão de genéricos

Você pode especificar tipos padrão para os genéricos quando nenhum tipo for fornecido. Exemplo:

Tarefa: Crie uma função genérica com um tipo padrão e teste-a com diferentes tipos.

function wrap<T = string>(value: T): T[] {
  return [value];
}

console.log(wrap("Hello")); // Output: ["Hello"]
console.log(wrap(42)); // Output: [42]

Muito bem!

Parabéns! Você aprendeu a usar genéricos em TypeScript para criar funções, classes e interfaces reutilizáveis e seguras quanto aos tipos. Os genéricos são uma ferramenta poderosa para escrever código flexível e escalável. Na próxima lição, exploraremos tipos avançados, como tipos mapeados e condicionais. Vamos continuar programando!