Any, unknown, never y void

En esta clase cerramos los fundamentos con cuatro tipos “especiales” de TypeScript: any, unknown, void y never.

Son tipos que representan casos extremos y, bien usados, te ayudan a escribir código más seguro y más fácil de mantener. Mal usados… te dejan TypeScript en modo “me da igual todo”.

any — el que desactiva TypeScript

any acepta cualquier valor y permite cualquier operación.

El problema no es solo que puedas hacer cosas incorrectas, es que TypeScript no te avisa, y el error te explota en tiempo de ejecución.

let value: any = 'hola'

value.saludar() // TypeScript: OK (pero ese método no existe)
value.toFixed(2) // TypeScript: OK (pero es un string, no un number)

¿Cuándo aparece any?

• Cuando no tipas una variable y TypeScript no puede inferir el tipo.
• Cuando haces un JSON.parse() (devuelve any).
• Cuando importas una librería sin tipos.

La regla de oro

Evita any siempre que puedas. Si lo usas, estás renunciando a todo lo que TypeScript te ofrece.

Si necesitas una válvula de escape, hay una opción mucho mejor: unknown.

unknown — la alternativa segura a any

unknown también acepta cualquier valor, pero con una diferencia fundamental: no te deja hacer nada con él hasta que compruebes el tipo.

let value: unknown = 'hola'

// value.toUpperCase() // Error: no se puede operar con unknown directamente

if (typeof value === 'string') {
  value.toUpperCase() // OK, TypeScript sabe que es string
}

Es como decirle a TypeScript: “no sé qué es esto, pero voy a comprobarlo antes de usarlo”.

any vs unknown

	any	unknown
Acepta cualquier valor	Sí	Sí
Permite cualquier operación	Sí (peligroso)	No (seguro)
Requiere comprobación de tipo	No	Sí

Regla práctica: si no sabes el tipo, usa unknown y comprueba. Nunca any.

void — la función que no devuelve nada útil

void es el tipo de retorno de funciones que no devuelven un valor.

function logMessage(message: string): void {
  console.log(message)
}

La función hace algo (imprimir en consola), pero no devuelve nada que te interese guardar.

¿Y si hago return sin valor?

function saludo(): void {
  console.log('Hola')
  return // OK, return sin valor es compatible con void
}

Esto es válido. void no significa “prohibido hacer return”, significa “el valor de retorno no tiene sentido usarlo”.

Diferencia con undefined

function returnUndefined(): undefined {
  return undefined // Obligatorio devolver explícitamente undefined
}

function returnVoid(): void {
  // No necesita devolver nada
}

En la práctica, void es lo que usarás el 99% de las veces para funciones sin retorno útil.

never — lo que nunca puede pasar

never es el tipo de algo que jamás ocurre. Suena raro, pero tiene dos usos muy claros:

1) Funciones que nunca terminan

function throwError(message: string): never {
  throw new Error(message)
}

function infiniteLoop(): never {
  while (true) {
    // nunca sale de aquí
  }
}

Estas funciones nunca llegan a devolver nada — ni void, ni undefined, ni nada. Por eso su tipo es never.

2) Control exhaustivo (exhaustive check)

Este es el uso más potente de never. Imagina un tipo unión:

type Shape = 'circle' | 'square' | 'triangle'

function getArea(shape: Shape) {
  switch (shape) {
    case 'circle':
      return Math.PI * 10 ** 2
    case 'square':
      return 10 * 10
    case 'triangle':
      return (10 * 5) / 2
    default:
      const _exhaustive: never = shape
      return _exhaustive
  }
}

Si mañana alguien añade 'rectangle' al tipo Shape pero se olvida de añadir el case, TypeScript dará error en el default porque 'rectangle' no es asignable a never.

Es una red de seguridad para que no se te olvide cubrir todos los casos.

Tabla resumen

Tipo	Qué representa	Ejemplo típico
any	”Me da igual el tipo”	Evitar siempre que puedas
unknown	”No sé el tipo, pero lo voy a comprobar”	Datos de API, JSON.parse
void	”No devuelvo nada útil”	console.log, event handlers
never	”Esto nunca pasa”	Throw, loops infinitos, exhaustive checks

Lo que hemos aprendido

• any desactiva TypeScript — es la última opción.
• unknown es la alternativa segura: acepta todo, pero exige comprobación.
• void indica que una función no devuelve un valor útil.
• never representa lo que nunca puede ocurrir — ideal para exhaustive checks.
• Con estos cuatro tipos cerramos los fundamentos del sistema de tipos de TypeScript.