Funciones Tipadas

Tipar funciones en TypeScript es anotar qué tipos entran (parámetros) y qué tipo sale (valor de retorno). La gran ventaja es que el editor te avisa inmediatamente si llamas la función con los tipos incorrectos o si intentas usar el resultado de una forma que no corresponde. Los parámetros opcionales (con ?) y los valores por defecto hacen que las funciones sean más flexibles sin sacrificar la seguridad de tipos.

Las sobrecargas de función (function overloads) permiten que una misma función acepte diferentes combinaciones de tipos de parámetros, y TypeScript sabe qué tipo devuelve en cada caso.

Los tipos de función (type Fn = (x: number) => string) son esenciales cuando trabajas con callbacks y higher-order functions: permiten anotar qué tipo de función espera recibir un parámetro. void significa que no interesa el valor de retorno, never que la función nunca retorna (lanza siempre una excepción).

// Función tipada básica
function dividir(a: number, b: number): number {
  if (b === 0) throw new Error("División por cero");
  return a / b;
}

// Parámetros opcionales y por defecto
function saludar(nombre: string, saludo: string = "Hola", veces?: number): string {
  return `${saludo}, ${nombre}!`.repeat(veces ?? 1);
}

// Rest params tipados
function suma(...numeros: number[]): number {
  return numeros.reduce((acc, n) => acc + n, 0);
}

// Tipo de función
type Transformador = (valor: string) => string;
const mayusculas: Transformador = (s) => s.toUpperCase();

// Higher-order functions tipadas
function aplicar<T>(arr: T[], fn: (item: T, idx: number) => T): T[] {
  return arr.map(fn);
}

// Function overloads
function formatear(valor: string): string;
function formatear(valor: number): string;
function formatear(valor: Date): string;
function formatear(valor: string | number | Date): string {
  if (typeof valor === "string") return valor.trim();
  if (typeof valor === "number") return valor.toFixed(2);
  return valor.toLocaleDateString("es-ES");
}

// void vs never vs undefined
function logear(msg: string): void { console.log(msg); } // No retorna nada
function lanzar(msg: string): never { throw new Error(msg); } // Nunca retorna
const fn: () => undefined = () => undefined; // Retorna undefined explícitamente