TypeScript Academy · Aula

O Tipo void em Funções

Entenda como void difere de undefined em posições de retorno de funções.

O Tipo void em Funções é 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.

O tipo de retorno void

void descreve uma função que não retorna nenhum valor útil. A função ainda é concluída; ela apenas não produz algo que deva ser utilizado. Esse é o tipo de funções chamadas por seus efeitos colaterais.

function log(message: string): void {
  console.log(message);
}
log('Hello void');

void inferido

Se uma função não tiver uma instrução return (ou tiver apenas um return; isolado), o TypeScript infere void automaticamente. Raramente é necessário escrevê-lo explicitamente, embora isso documente a intenção.

function greet(name: string) {
  console.log('Hi ' + name);
  // no return -> inferred void
}
greet('Ada');

void vs undefined

Eles estão relacionados, mas não são iguais. Uma função void pode ou não retornar de fato undefined, e não se deve depender de seu valor de retorno. Uma função tipada para retornar undefined deve retorná-lo explicitamente.

function a(): void { /* returns nothing useful */ }
function b(): undefined { return undefined; }
console.log(a(), b());

Você não deve usar um resultado void

O valor em tempo de execução de uma chamada de void é undefined, mas o sistema de tipos desencoraja seu uso. Trate void como “ignore este retorno”.

function save(): void {
  console.log('saved');
}
const result = save(); // result has type void
console.log(result); // undefined at runtime

void em tipos de funções de retorno

Uma regra sutil e poderosa: uma função de retorno tipada para retornar void pode ser compatível com uma função que retorna qualquer valor. O valor de retorno extra é simplesmente ignorado.

type Handler = () => void;

const h: Handler = () => 42; // returns number, still fine
h();
console.log('Returned value is ignored by callers');

Por que essa regra existe

Essa flexibilidade permite passar funções como arr.push (que retorna um número) como funções de retorno void. O chamador prometeu não usar o valor de retorno, portanto qualquer retorno é inofensivo.

const items: number[] = [];
const nums = [1, 2, 3];
nums.forEach((n) => items.push(n)); // push returns number, ok
console.log(items);

void contextual nos métodos de array

forEach espera uma função de retorno que retorne void. É por isso que você pode escrever uma função de seta de uma linha que retorna um valor incidentalmente sem causar um erro — o tipo void contextual o absorve.

const result: string[] = [];
['a', 'b'].forEach((x) => result.push(x.toUpperCase()));
console.log(result);

Uma confusão comum

A regra de funções de retorno void se aplica ao tipo da função de retorno, não a funções cuja própria anotação de retorno é void. Uma função declarada literalmente como (): void ainda não pode ter um return value; com um valor diferente de undefined.

function f(): void {
  return; // ok
  // return 5; // Error: 5 not assignable to void
}
f();
console.log('declared void cannot return a value');

Parâmetros void são incomuns

Embora seja raro, void pode aparecer como tipo de parâmetro em genéricos avançados. No código cotidiano, quase sempre você o verá como tipo de retorno, indicando “nenhum resultado significativo”.

type Listener = (event: string) => void;

const onClick: Listener = (e) => console.log('Event:', e);
onClick('click');

void com promessas

Funções assíncronas frequentemente retornam Promise<void> quando realizam uma tarefa, mas são resolvidas sem nenhum valor. Esse padrão corresponde ao void síncrono no código assíncrono.

async function sync(): Promise<void> {
  console.log('syncing...');
  // resolves with no value
}
sync().then(() => console.log('done'));

Escolhendo void deliberadamente

Anote void quando quiser comunicar que uma função existe por causa de seus efeitos colaterais e que os chamadores não devem depender de um valor de retorno. Isso esclarece a intenção e permite aproveitar a regra flexível das funções de retorno.

function notify(msg: string): void {
  console.log('NOTIFY:', msg);
}
const handlers: Array<(m: string) => void> = [notify];
handlers.forEach((fn) => fn('ping'));

Verificação rápida

Verifique sua compreensão do tipo void.

Recapitulação: void

Você aprendeu que void:

Indica funções que retornam nenhum valor útil.
É diferente de undefined: resultados void não devem ser usados.
Como tipo de função de retorno, aceita funções que retornam qualquer valor (ignorado pelos chamadores).
Permite usar métodos como push de forma limpa dentro de forEach.

Em seguida, reuniremos tudo: como lidar com segurança com unknown.

const tasks: Array<() => void> = [
  () => console.log('task 1'),
  () => console.log('task 2')
];
tasks.forEach((t) => t());

Perguntas Frequentes

A aula “O Tipo void em Funções” é grátis?

Sim — o texto completo de “O Tipo void em 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 “O Tipo void em Funções”?

Entenda como void difere de undefined em posições de retorno de funções. 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 “O Tipo void em 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

← Voltar para TypeScript Academy