TypeScript Academy · Aula

Funções genéricas: parâmetros de tipo

Adicione parâmetros de tipo às funções para reutilizá-las

Funções genéricas: parâmetros de tipo é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Boas-vindas

Os genéricos permitem escrever funções que funcionam com qualquer tipo, preservando a segurança de tipos. Em vez de usar `any`, você usa um parâmetro de tipo que é resolvido quando a função é chamada.

O problema resolvido pelos genéricos

Uma função que retorna `any` perde as informações de tipo. Os genéricos preservam a relação entre os tipos de entrada e de saída.

// Without generics — loses type info
function first(arr: any[]): any { return arr[0]; }

// With generics — type-safe
function first<T>(arr: T[]): T { return arr[0]; }

Sintaxe de parâmetros de tipo

Declare um parâmetro de tipo com colchetes angulares `` antes da lista de parâmetros. Use T nos parâmetros e no tipo de retorno.

function identity<T>(value: T): T {
  return value;
}
const n = identity(42);       // T is number
const s = identity('hello');  // T is string

Inferência de tipos para funções genéricas

O TypeScript infere o argumento de tipo a partir do argumento real. Raramente é necessário especificá-lo explicitamente.

function wrap<T>(val: T): T[] { return [val]; }
const nums = wrap(42);    // T inferred as number -> number[]
const strs = wrap('hi');  // T inferred as string -> string[]

Vários parâmetros de tipo

As funções podem ter vários parâmetros de tipo.

function pair<A, B>(a: A, b: B): [A, B] {
  return [a, b];
}
const p = pair(1, 'hello'); // [number, string]

Funções genéricas para matrizes

Os genéricos são essenciais para funções utilitárias de matrizes que funcionam com qualquer tipo de elemento.

function filterNull<T>(arr: (T | null)[]): T[] {
  return arr.filter((x): x is T => x !== null);
}

Argumentos de tipo explícitos

Você pode fornecer argumentos de tipo explicitamente quando o TypeScript não consegue inferi-los.

function create<T>(): T | null { return null; }
const user = create<User>(); // T cannot be inferred — must be explicit

Genérico versus any

Ao contrário de `any`, os genéricos mantêm a relação entre os tipos ao longo da função. O tipo de retorno fica vinculado ao tipo de entrada.

function echo<T>(val: T): T { return val; }
const n: number = echo(42);   // OK
// const s: string = echo(42); // Error — T is number

Funções de seta genéricas

As funções de seta usam a mesma sintaxe, mas precisam de uma vírgula em arquivos .tsx para serem diferenciadas das tags JSX.

const identity = <T>(val: T): T => val;
// In .tsx files:
const identity2 = <T,>(val: T): T => val;

Retornando um tipo diferente

As funções genéricas podem usar o parâmetro de tipo de maneiras transformadas.

function mapArray<T, U>(arr: T[], fn: (item: T) => U): U[] {
  return arr.map(fn);
}
const lengths = mapArray(['hello', 'world'], s => s.length);
// lengths: number[]

Parâmetros genéricos com valores padrão

Forneça um tipo padrão para um parâmetro de tipo a fim de torná-lo opcional.

function createList<T = string>(): T[] { return []; }
const list = createList(); // T defaults to string

Verificação rápida

Qual é o tipo de retorno de `identity(42)`?

Recapitulação

As funções genéricas usam parâmetros de tipo (T) para preservar as relações entre entradas e saídas. O TypeScript infere os argumentos de tipo automaticamente. Use genéricos em vez de any para escrever utilitários reutilizáveis e seguros quanto aos tipos.

Perguntas Frequentes

A aula “Funções genéricas: parâmetros de tipo” é grátis?

Sim — o texto completo de “Funções genéricas: parâmetros de tipo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Funções genéricas: parâmetros de tipo”?

Adicione parâmetros de tipo às funções para reutilizá-las Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Funções genéricas: parâmetros de tipo”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para TypeScript Academy