TypeScript Academy · Lección

El tipo never y los estados imposibles

Modele código inalcanzable y valores imposibles con never.

El tipo never y los estados imposibles es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 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 never

never es el tipo vacío: representa valores que nunca pueden producirse. Ningún valor se puede asignar a never (salvo never en sí mismo). Marca situaciones que deberían ser imposibles.

// You cannot create a value of type never
function crash(): never {
  throw new Error('boom');
}
try { crash(); } catch (e) { console.log('caught'); }

Funciones que nunca devuelven un resultado

Una función que siempre ejecuta throw nunca devuelve un resultado normalmente, por lo que su tipo de retorno es never. Esto indica a los llamadores y al compilador que la ejecución se detiene aquí.

function fail(message: string): never {
  throw new Error(message);
}
try { fail('invalid'); } catch (e) { console.log('handled'); }

Los bucles infinitos devuelven never

Una función con un bucle infinito tampoco devuelve nunca un resultado, por lo que también se tipa como never. El compilador reconoce que el flujo de control no puede continuar después de ella.

function listen(): never {
  while (true) {
    // forever
    break; // (break added so the demo terminates)
  }
  throw new Error('stopped');
}
console.log('listen has return type never');

never frente a void

No confunda never con void. Una función void sí devuelve un resultado, aunque no produzca ningún valor útil. Una función never no devuelve ningún resultado: lanza una excepción o entra en un bucle infinito.

function logIt(): void {
  console.log('done'); // returns normally
}
function abort(): never {
  throw new Error('stop'); // never returns
}
logIt();
try { abort(); } catch (e) { console.log('ok'); }

never en las comprobaciones de exhaustividad

El uso más práctico de never es comprobar la exhaustividad. En el caso predeterminado de un switch, asigne la variable a un never. Si se han gestionado todos los casos, la variable ya es never y el código compila.

type Shape = 'circle' | 'square';

function area(s: Shape): string {
  switch (s) {
    case 'circle': return 'pi r^2';
    case 'square': return 'a^2';
    default:
      const _check: never = s; // ok: all handled
      return _check;
  }
}
console.log(area('square'));

Detectar casos omitidos

Si alguien añade un nuevo miembro a la unión, pero olvida un caso, el valor restante deja de ser never, por lo que la asignación no compila. La comprobación con never convierte una omisión silenciosa en un error evidente.

type Shape = 'circle' | 'square' | 'triangle';
// If 'triangle' case is missing, assigning s to never
// would error: 'triangle' is not assignable to never.
console.log('Add a case for every member');

never en ramas imposibles de una unión

Cuando la reducción elimina todas las posibilidades, el tipo restante es never. El compilador sabe que esa rama es inalcanzable, lo que puede revelar errores de lógica.

function check(x: string | number): void {
  if (typeof x === 'string') {
    console.log('string');
  } else if (typeof x === 'number') {
    console.log('number');
  } else {
    // x is never here
    console.log('unreachable');
  }
}
check('hi');

never como tipo inferior

never es el tipo inferior: se puede asignar a cualquier otro tipo, porque un valor que no puede existir es trivialmente compatible con cualquier cosa. Por eso un throw puede aparecer en cualquier posición de una expresión.

function getOrThrow(v: string | null): string {
  return v ?? fail();
}
function fail(): never {
  throw new Error('missing');
}
console.log(getOrThrow('value'));

Filtrar uniones a never

En los tipos condicionales y mapeados, never actúa como «eliminar esto». Unir algo con never no cambia nada: T | never es simplemente T. Por eso es la opción natural para filtrar.

type Keep<T> = T extends string ? T : never;
type R = Keep<'a' | 1 | 'b'>; // 'a' | 'b'
const x: R = 'a';
console.log(x);

Modelar estados imposibles

Use never en las formas de los objetos para hacer que las combinaciones ilegales no se puedan representar. Aquí, un estado de «carga» no puede contener también datos, porque el tipo lo impide.

type State =
  | { status: 'loading'; data?: never }
  | { status: 'ready'; data: number };

const s: State = { status: 'ready', data: 7 };
console.log(s);

never mejora la seguridad de las refactorizaciones

Como las comprobaciones de exhaustividad con never fallan cuando falta un caso, hacen que las refactorizaciones sean más seguras: amplíe una unión y el compilador le indicará todos los lugares que deben actualizarse.

type Cmd = 'start' | 'stop';
function run(c: Cmd): string {
  if (c === 'start') return 'starting';
  if (c === 'stop') return 'stopping';
  const _x: never = c;
  return _x;
}
console.log(run('start'));

Comprobación rápida

Compruebe cuánto ha comprendido sobre el tipo never.

Resumen: never

Ha aprendido que never:

Es el tipo vacío: ningún valor puede pertenecer al tipo never.
Es el tipo de retorno de las funciones que lanzan excepciones o entran en un bucle infinito.
Habilita las comprobaciones de exhaustividad en los casos default de switch.
Aparece en ramas de estrechamiento imposibles y filtra uniones en la lógica de tipos.

A continuación, veremos void y en qué se diferencia.

function assertNever(x: never): never {
  throw new Error('Unexpected: ' + String(x));
}
console.log('assertNever guards exhaustiveness');

Preguntas frecuentes

¿La lección «El tipo never y los estados imposibles» es gratis?

Sí — el texto completo de «El tipo never y los estados imposibles» 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 never y los estados imposibles»?

Modele código inalcanzable y valores imposibles con never. 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 2 de 4.

¿Cuánto tiempo toma la lección «El tipo never y los estados imposibles»?

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