¿Cuál es la diferencia entre los tipos de retorno `void`, `undefined` y `never`?

`void` significa que el valor de retorno de la función no tiene importancia (puede ser ignorado). `undefined` requiere un retorno explícito de `undefined`. `never` garantiza que la función nunca terminará con un retorno de control normal (lanzará una excepción o entrará en un bucle infinito).

¿Cómo tipar una función asíncrona que no devuelve nada?

Con el tipo `Promise `. Cualquier función `async` siempre envuelve el resultado en una promesa, por lo que devolver un `void` simple sin `Promise` es un error de sintaxis.

¿Cómo infiere el tipado contextual (Contextual Typing) los tipos de los parámetros de los callbacks?

El compilador examina el lugar donde se pasa la función. Si la función se pasa a un parámetro con el tipo `(item: string) => void`, entonces el argumento del callback `arr.forEach(x => ...)` recibe automáticamente el tipo `string` sin necesidad de especificar `x: string` explícitamente.

¿Se puede tipar el parámetro `this` dentro de una función?

Sí. En TypeScript, se puede declarar un primer parámetro ficticio `this`: `function handleClick(this: HTMLButtonElement, event: Event) { this.disabled = true; }`. Este parámetro se elimina completamente durante la compilación y se utiliza solo para verificar el contexto de la llamada.

¿Por qué los parámetros de las funciones se verifican de forma contravariante?

Porque el llamador pasa argumentos a la función. Si una función espera un tipo base (por ejemplo, `Entity`), es seguro pasarle una función que pueda manejar cualquier supertipo, pero no se le puede pasar una función que requiera un subtipo específico (`User`), ya que al acceder a los campos de `User` se produciría un error en tiempo de ejecución.

¿En qué se diferencian las sobrecargas de funciones (Function Overloads) de los tipos condicionales (Conditional Types) en las funciones?

Las sobrecargas son útiles para escenarios de uso discretos y bien definidos, y proporcionan sugerencias más claras en el IDE. Los tipos condicionales basados en genéricos (`T extends string ? A : B`) son preferibles cuando la lógica de inferencia del tipo de retorno depende continuamente del tipo del argumento.

Tipado de Funciones, Promesas, Callbacks y Firmas — Dominio de TypeScript 5.8+

Base Arquitectónica#

Las funciones en TypeScript son ciudadanos de primera clase (First-Class Citizens). Pueden pasarse como argumentos, devolverse desde otras funciones y asignarse a variables.

El tipado de una función representa un contrato matemático formal: f: (A1, A2, ...An) -> R El contrato define un conjunto de parámetros de entrada y la garantía del tipo de valor de retorno.

A diferencia de muchos lenguajes de tipado estático, las funciones en TypeScript poseen propiedades únicas:

Contravarianza de parámetros: los parámetros de las funciones se comparan de forma estrictamente contravariante cuando la bandera strictFunctionTypes está activada.
Covarianza de retorno: el valor de retorno se verifica de forma covariante (una función que devuelve un subtipo es compatible con el código que espera un supertipo).
Semántica de ausencia de valor (void vs undefined vs never): distinción entre funciones sin un resultado útil, el retorno de undefined y funciones que nunca devuelven el control (bucles infinitos, lanzamiento de excepciones).
Sobrecarga de funciones (Function Overloads): declaración de múltiples firmas públicas para una única función de implementación interna.

Modelo Mental#

Veamos las diferencias entre void, undefined y never:

text

+-------------------------------------------------------------------------+
|                  SEMÁNTICA DE RETORNO: VOID vs UNDEFINED vs NEVER       |
+-------------------------------------------------------------------------+
| void:                                                                   |
|   "No me importa el resultado". La función realiza un efecto secundario.|
|   En JS devolverá undefined, pero TypeScript permite que los callbacks  |
|   devuelvan cualquier valor, ignorándolo por parte del llamador.        |
+-------------------------------------------------------------------------+
| undefined:                                                              |
|   "La función devuelve explícitamente el valor undefined".              |
|   Es obligatorio return undefined o un return vacío.                    |
+-------------------------------------------------------------------------+
| never:                                                                  |
|   "La función NUNCA terminará normalmente".                             |
|   O bien lanza un error throw new Error(), o se queda en un bucle while.|
+-------------------------------------------------------------------------+

Call Signature (Firma de Llamada)
Function Overloads (Sobrecarga de Funciones)
Rest Parameters (Parámetros Rest)
Tipado Contextual (Contextual Typing)

Pipeline de Coincidencia de Firmas de Funciones#

Cómo el compilador de TypeScript compara las firmas de funciones

1. Verificación del número de argumentos

La función que llama puede pasar menos argumentos de los declarados, pero no más de los requeridos (verificación de aridad).

2. Verificación contravariante de parámetros

Cada parámetro de la función objetivo debe aceptar de forma segura el tipo del argumento correspondiente de la función original.

3. Verificación covariante de retorno

El tipo de resultado de la función original debe ser un subtipo del tipo de retorno declarado de la firma objetivo.

4. Resolución de sobrecargas (Overload Resolution)

El compilador compara los argumentos de la llamada con las sobrecargas de arriba a abajo hasta la primera coincidencia completa.

PUNTO DE CONTROL #1

Verificación de comprensión: Semántica de void en callbacks

+15 XP

¿Por qué el compilador permite que el código `const fn: () => void = () => 42;` pase la verificación de tipos con éxito, a pesar de que la función flecha devuelve un número?

Aplicación Práctica#

Manejadores de eventos en UI (React / DOM): tipado estricto de los parámetros de eventos (event: React.MouseEvent<HTMLButtonElement>) => void.
Contratos asíncronos y promesas: especificación explícita del tipo de promesa async function fetchEntity(): Promise<Entity> para protegerse contra un Promise<unknown> implícito.
Patrón de sobrecargas en SDK y utilidades: creación de APIs ergonómicas que devuelven diferentes tipos según el formato de los argumentos (readFile(path, 'utf-8'): string vs readFile(path): Buffer).
Pipelines de funciones de orden superior (Currying / Middleware): tipado de compositores de funciones que pasan el resultado de la llamada anterior como entrada a la siguiente.

Cómo Funciona#

1. Declaración de firmas: tipos de flecha vs objetos con llamada#

La firma de una función se puede declarar como un tipo de flecha o dentro del cuerpo de una interfaz:

typescriptDeclaración de tipos funcionales

// 1. Alias de tipo de flecha:
type FormValidator = (value: string, minLength?: number) => boolean;

// 2. Tipo de objeto con firma de llamada (Call Signature):
interface Logger {
  // Firma de llamada
  (message: string, level?: 'info' | 'warn' | 'error'): void;
  // Propiedad estática adjunta a la función
  defaultLevel: 'info' | 'warn' | 'error';
}

const consoleLogger: Logger = Object.assign(
  (msg: string, level: 'info' | 'warn' | 'error' = 'info') => {
    console.log(`[${level.toUpperCase()}] ${msg}`);
  },
  { defaultLevel: 'info' as const }
);

2. Sobrecarga de funciones (Function Overloads)#

Una sobrecarga consta de uno o más encabezados de sobrecarga (sin cuerpo) y una firma de implementación (con cuerpo):

typescriptImplementación correcta de la sobrecarga de funciones

// Sobrecargas públicas (visibles para los consumidores de la API)
function formatTimestamp(timestamp: number): string;
function formatTimestamp(date: Date, locale: string): string;

// Firma de implementación (¡NO visible directamente para los consumidores!)
function formatTimestamp(arg1: number | Date, arg2?: string): string {
  if (typeof arg1 === 'number') {
    return new Date(arg1).toISOString();
  }
  return arg1.toLocaleDateString(arg2 ?? 'en-US');
}

// Llamadas correctas:
formatTimestamp(1728000000000); // OK
formatTimestamp(new Date(), 'ru-RU'); // OK

// ERROR: ¡el compilador solo compara con las sobrecargas públicas, no con la implementación!
// formatTimestamp(new Date()); // TS2554: Expected 2 arguments, but got 1.

3. Parámetros opcionales y valores por defecto#

Los parámetros opcionales (param?: Type) deben seguir estrictamente a los parámetros obligatorios:

typescriptParámetros de funciones y tuplas Rest

// Los parámetros por defecto hacen que el parámetro sea opcional automáticamente
function createRequest(
  url: string,
  timeoutMs: number = 5000,
  headers?: Record<string, string>
) {
  return { url, timeoutMs, headers: headers ?? {} };
}

// Parámetros Rest tipados usando tuplas:
type LogArgs = [code: number, message: string, ...details: unknown[]];

function emitAuditLog(...args: LogArgs): void {
  const [code, message, ...details] = args;
  console.log(`Audit #${code}: ${message}`, details);
}

emitAuditLog(403, 'Forbidden', { ip: '127.0.0.1' }); // Correcto

PUNTO DE CONTROL #2

Verificación de comprensión: Firma de implementación en sobrecargas

+15 XP

¿Por qué el código que llama no puede invocar una función con argumentos que coincidan con la firma de implementación, si esa combinación no existe en las sobrecargas públicas?

Errores comunes#

Ошибка: Orden de las sobrecargas de lo general a lo particular

TypeScript compara las sobrecargas de arriba a abajo. Si se coloca una firma más amplia primero, interceptará todas las llamadas:

typescript

// ERROR: ¡la primera sobrecarga bloqueará la segunda!
function get(url: string): unknown;
function get(url: 'https://api.wpskills.dev'): SpecificResponse;

// CORRECTO: ¡coloque las firmas específicas PRIMERO y las amplias al final!
function get(url: 'https://api.wpskills.dev'): SpecificResponse;
function get(url: string): unknown;

Ошибка: Confusión entre void y never en funciones

Declaración de una función con never si termina de forma normal:

typescript

// ERROR: TS2534: A function returning 'never' cannot have a reachable end point.
function logError(msg: string): never {
  console.error(msg);
  // ¡No hay throw o while(true)!
}

Use void para funciones que realizan un efecto secundario.

Entrevista: Preguntas y Respuestas#

Preguntas de entrevista6 preguntas

Temas relacionados

Uniones, Intersecciones y estrechamiento de tipos en TypeScript— Patrones de estrechamiento y uniones discriminadas.Introducción a los Genéricos y los Tipos de Utilidad básicos— Programación genérica y utilidades estándar Partial, Pick, Omit.