PricingLoginStart free
TypeScript Academy · Aula

void, never e assinaturas de funções

Entenda void para funções sem retorno e never para código inalcançável

Aula 4 de 413 etapas

void, never e assinaturas de funções é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 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

Dois tipos de retorno especiais — void e never — representam funções que não produzem um valor útil e funções que nunca terminam normalmente.

void: sem retorno significativo

void é usado quando uma função executa um efeito colateral, mas não retorna um valor. Ele permite retornar undefined, mas indica que o valor de retorno não deve ser usado.
function logError(msg: string): void {
  console.error(msg);
  // implicit return undefined
}

Diferença entre void e undefined

void e undefined são semelhantes, mas diferentes. Uma função tipada como void pode retornar undefined. Porém, void indica que o chamador deve ignorar o valor de retorno.
const fn: () => void = () => 42; // Allowed! Caller ignores return
const fn2: () => undefined = () => 42; // Error

void em funções de retorno de chamada

Ao tipar um parâmetro de função de retorno de chamada, void indica que o chamador não usa o valor de retorno. Isso permite que as funções de retorno de chamada retornem qualquer tipo.
function run(cb: () => void): void { cb(); }
run(() => 'hello'); // OK — return value ignored

never: o tipo inalcançável

never representa um valor que nunca ocorre. Uma função que retorna never lança uma exceção ou executa um laço infinito.
function fail(msg: string): never {
  throw new Error(msg);
}
function loop(): never {
  while (true) {}
}

never nas verificações de exaustividade

never é usado em instruções switch para garantir que todos os casos da união sejam tratados. Atribuir a never causa um erro quando um caso é esquecido.
type Shape = 'circle' | 'square';
function area(s: Shape): number {
  switch (s) {
    case 'circle': return 3.14;
    case 'square': return 1;
    default:
      const _: never = s; // Error if a new shape is added
      return 0;
  }
}

never é um subtipo de tudo

never pode ser atribuído a qualquer tipo (ele nunca acontece, portanto satisfaz qualquer tipo de forma vazia). Nenhum outro tipo pode ser atribuído a never.

Assinaturas de tipo de função

Um tipo de função é escrito como `(param: Type) => ReturnType`. Isso descreve funções como values de primeira classe.
type Handler = (event: MouseEvent) => void;
type Transform = (input: string) => string;

Assinaturas de chamada em interfaces

As interfaces podem definir tipos chamáveis usando uma sintaxe de assinatura de chamada.
interface Formatter {
  (value: string): string;
  locale: string;
}

Assinaturas de construção

As interfaces também podem definir tipos construtíveis usando a palavra-chave new em uma assinatura de construção.
interface Constructor {
  new (name: string): Animal;
}

Combinando void e never no tratamento de erros

As funções que sempre lançam exceções usam never. As funções que engolem erros e não retornam nada usam void. Essa distinção é importante para a análise do fluxo de controle.
function orThrow(val: string | null): string {
  if (val === null) fail('null!'); // never
  return val; // TypeScript knows this is reachable
}

Verificação rápida

Qual tipo de retorno indica que uma função sempre lançará um erro e nunca retornará normalmente?
Responda na aula interativa

Recapitulação

Use void para funções de efeitos colaterais sem retorno significativo. Use never para funções que lançam exceções ou executam laços. never permite verificar a exaustividade e é um subtipo de todos os tipos.
Grátis para começar

Aprenda TypeScript com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
101
Aulas
352
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “void, never e assinaturas de funções” é grátis?

Sim — o texto completo de “void, never e assinaturas de funções” é 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 “void, never e assinaturas de funções”?

Entenda void para funções sem retorno e never para código inalcançável 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 4 de 4.

Quanto tempo leva a aula “void, never e assinaturas de funções”?

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

  1. Anotações de tipos de parâmetros e retornos
  2. Parâmetros opcionais e padrão
  3. Parâmetros rest e spread com tipos
  4. void, never e assinaturas de funções
← Voltar para TypeScript Academy