TypeScript Academy · Lección

El tipo void en funciones

Comprenda en qué se diferencia void de undefined en las posiciones de retorno de las funciones.

El tipo void en funciones es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

El tipo de retorno void

void describe una función que no devuelve ningún valor útil. La función se completa igualmente; simplemente no produce nada que deba utilizar. Es el tipo de las funciones que se llaman por sus efectos secundarios.

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

void inferido

Si una función no tiene ninguna instrucción return (o solo tiene return; sin expresión), TypeScript infiere void automáticamente. Rara vez necesita escribirlo explícitamente, aunque documenta la intención.

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

void frente a undefined

Están relacionados, pero no son lo mismo. Una función void puede devolver realmente undefined o no devolverlo, y no debe depender de su valor de retorno. Una función cuyo tipo de retorno es undefined debe devolverlo explícitamente.

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

No debería usar un resultado void

El valor en tiempo de ejecución de una llamada a void es undefined, pero el sistema de tipos desaconseja utilizarlo. Considere void como «ignore este valor de retorno».

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

void en los tipos de callback

Una regla sutil y potente: un callback cuyo tipo de retorno es void puede recibir una función que devuelva cualquier valor. El valor de retorno adicional simplemente se ignora.

type Handler = () => void;

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

Por qué existe esta regla

Esta flexibilidad permite pasar funciones como arr.push (que devuelve un número) como callbacks void. El código llamador se comprometió a no usar el valor de retorno, por lo que cualquier retorno es inofensivo.

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

void contextual en los métodos de arrays

forEach espera un callback que devuelva void. Por eso puede escribir una función flecha de una sola línea que devuelva incidentalmente un valor sin producir un error: el tipo contextual void lo absorbe.

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

Una confusión habitual

La regla para callbacks void se aplica al tipo del callback, no a las funciones cuyo retorno está anotado como void. Una función declarada literalmente como (): void tampoco puede tener un return value; con un valor distinto de undefined.

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

Los parámetros void son poco habituales

Aunque es poco frecuente, void puede aparecer como tipo de parámetro en genéricos avanzados. En el código cotidiano, casi siempre lo verá como tipo de retorno, indicando «ningún resultado significativo».

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

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

void con promesas

Las funciones asíncronas suelen devolver Promise<void> cuando realizan un trabajo, pero se resuelven sin ningún valor. Este patrón refleja el uso síncrono de void en código asíncrono.

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

Elegir void deliberadamente

Anote void cuando quiera comunicar que una función existe por sus efectos secundarios y que quienes la llamen no deben depender de un valor de retorno. Esto aclara la intención y le permite aprovechar la regla flexible de los callbacks.

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

Comprobación rápida

Compruebe cuánto entiende del tipo void.

Resumen: void

Ha aprendido que void:

Marca las funciones que devuelven ningún valor útil.
Se diferencia de undefined: no se deben utilizar los resultados void.
Como tipo de callback, acepta funciones que devuelven cualquier valor, que los llamadores ignoran.
Permite utilizar métodos como push de forma sencilla dentro de forEach.

A continuación, lo combinaremos todo para gestionar unknown de forma segura.

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

Preguntas frecuentes

¿La lección «El tipo void en funciones» es gratis?

Sí — el texto completo de «El tipo void en funciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «El tipo void en funciones»?

Comprenda en qué se diferencia void de undefined en las posiciones de retorno de las funciones. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «El tipo void en funciones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a TypeScript Academy