TypeScript Academy · Aula

Restrições genéricas com extends

Restrinja os parâmetros de tipo a formatos específicos

Restrições genéricas com extends é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 3 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

As restrições genéricas limitam quais tipos podem ser passados como argumentos de tipo. Use `extends` para exigir que T tenha determinadas propriedades ou corresponda a uma determinada forma.

O problema sem restrições

Sem restrições, o TypeScript não sabe quais operações são válidas em T, então permite apenas operações comuns a todos os tipos.

function getLength<T>(val: T): number {
  // return val.length; // Error — T might not have .length
}

Adicionando uma restrição

Use `T extends Shape` para exigir que T tenha pelo menos as propriedades de Shape.

function getLength<T extends { length: number }>(val: T): number {
  return val.length;
}
getLength('hello');  // OK — string has .length
getLength([1, 2]);   // OK — array has .length
// getLength(42);   // Error — number has no .length

Restringindo a uma interface

Restrinja T para que implemente uma interface específica.

interface Named { name: string; }
function greet<T extends Named>(person: T): string {
  return 'Hello, ' + person.name;
}

Restrição com keyof

Use `K extends keyof T` para restringir K às chaves de T. Isso permite acessar propriedades com segurança.

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const age = getProperty({ name: 'Alice', age: 30 }, 'age'); // number

Estendendo uma união

T pode ser restringido a um tipo união, limitando o argumento de tipo a valores específicos.

type Status = 'active' | 'inactive' | 'banned';
function setStatus<T extends Status>(status: T): void {
  console.log('Setting status:', status);
}

Restringindo a um construtor

Restrinja T para que seja uma classe (tenha um construtor), a fim de poder criar instâncias dentro da função.

function create<T>(ctor: new () => T): T {
  return new ctor();
}

Várias restrições com interseção

Restrinja T para que satisfaça várias interfaces usando uma interseção.

interface Serializable { serialize(): string; }
interface Loggable { log(): void; }
function process<T extends Serializable & Loggable>(item: T): void {
  item.log();
  console.log(item.serialize());
}

Herança de restrições

As restrições funcionam com herança. Se T estender uma classe base, você poderá chamar todos os métodos da classe base.

class Animal { breathe() { return 'breathing'; } }
function care<T extends Animal>(a: T): string { return a.breathe(); }

T estende a si mesmo (recursivo)

As restrições podem ser autorreferentes para estruturas de dados recursivas.

interface Comparable<T> { compareTo(other: T): number; }
function max<T extends Comparable<T>>(a: T, b: T): T {
  return a.compareTo(b) >= 0 ? a : b;
}

Mensagens de erro de restrição

Quando um argumento de tipo não satisfaz uma restrição, o TypeScript informa um erro claro, identificando tanto o argumento quanto a restrição.

Verificação rápida

A que `K extends keyof T` restringe K?

Recapitulação

Use `T extends SomeType` para restringir parâmetros de tipo genéricos. Isso permite chamar métodos específicos em T, usar keyof para acessar propriedades com segurança e criar utilitários seguros quanto aos tipos.

Perguntas Frequentes

A aula “Restrições genéricas com extends” é grátis?

Sim — o texto completo de “Restrições genéricas com extends” é 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 “Restrições genéricas com extends”?

Restrinja os parâmetros de tipo a formatos específicos 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 3 de 4.

Quanto tempo leva a aula “Restrições genéricas com extends”?

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