PricingLoginStart free
TypeScript Academy · Lección

void, never y firmas de funciones

Comprenda void para funciones sin valor devuelto y never para código inalcanzable.

Lección 4 de 413 pasos

void, never y firmas de funciones es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 4 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.

Introducción

Dos tipos de retorno especiales —void y never— representan, respectivamente, funciones que no producen un valor útil y funciones que nunca terminan normalmente.

void: sin retorno significativo

void se usa cuando una función realiza un efecto secundario, pero no devuelve ningún valor. Permite devolver undefined, pero indica que el valor de retorno no debe utilizarse.
function logError(msg: string): void {
  console.error(msg);
  // implicit return undefined
}

Diferencia entre void y undefined

void y undefined son similares, pero diferentes. Una función tipada como void puede devolver undefined. Sin embargo, void indica que quien realiza la llamada debe ignorar el valor de retorno.
const fn: () => void = () => 42; // Allowed! Caller ignores return
const fn2: () => undefined = () => 42; // Error

void en callbacks

Al tipar un parámetro callback, void indica que quien realiza la llamada no utiliza el valor de retorno. Esto permite que los callbacks devuelvan cualquier tipo.
function run(cb: () => void): void { cb(); }
run(() => 'hello'); // OK — return value ignored

never: el tipo inalcanzable

never representa un valor que nunca se produce. Una función que devuelve never produce una excepción o entra en un bucle infinito.
function fail(msg: string): never {
  throw new Error(msg);
}
function loop(): never {
  while (true) {}
}

never en comprobaciones de exhaustividad

never se usa en instrucciones switch para garantizar que se gestionen todos los casos de una unión. Asignar un valor a never provoca un error si falta algún caso.
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 es un subtipo de todo

never se puede asignar a cualquier tipo (nunca ocurre, por lo que satisface cualquier tipo de forma vacía). Ningún otro tipo se puede asignar a never.

Signaturas de tipos de función

Un tipo de función se escribe como `(param: Type) => ReturnType`. Esto describe las funciones como valores de primera clase.
type Handler = (event: MouseEvent) => void;
type Transform = (input: string) => string;

Signaturas de llamada en interfaces

Las interfaces pueden definir tipos invocables mediante la sintaxis de una signatura de llamada.
interface Formatter {
  (value: string): string;
  locale: string;
}

Signaturas de construcción

Las interfaces también pueden definir tipos construibles mediante la palabra clave new en una signatura de construcción.
interface Constructor {
  new (name: string): Animal;
}

Combinación de void y never en el control de errores

Las funciones que siempre producen una excepción usan never. Las funciones que absorben los errores y no devuelven nada usan void. Esta distinción es importante para el análisis del flujo de control.
function orThrow(val: string | null): string {
  if (val === null) fail('null!'); // never
  return val; // TypeScript knows this is reachable
}

Comprobación rápida

¿Qué tipo de retorno indica que una función siempre producirá una excepción y nunca retornará normalmente?
Responde en la lección interactiva

Resumen

Use void para funciones con efectos secundarios y sin un retorno significativo. Use never para funciones que producen excepciones o entran en bucles. never permite comprobar la exhaustividad y es un subtipo de todos los tipos.
Gratis para empezar

Aprende TypeScript con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
101
Lecciones
352
Empezar a aprender gratisVer el curso completo

Preguntas frecuentes

¿La lección «void, never y firmas de funciones» es gratis?

Sí — el texto completo de «void, never y firmas de 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 «void, never y firmas de funciones»?

Comprenda void para funciones sin valor devuelto y never para código inalcanzable. 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 4 de 4.

¿Cuánto tiempo toma la lección «void, never y firmas de 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

  1. Anotaciones de tipos de parámetros y valores devueltos
  2. Parámetros opcionales y predeterminados
  3. Parámetros rest y spread con tipos
  4. void, never y firmas de funciones
← Volver a TypeScript Academy