Tipado de funciones variádicas
Cree API flexibles con tipos de tuplas variádicas.
Tipado de funciones variádicas 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.
Funciones genéricas variádicas
Los tipos de tupla variádicos permiten que los genéricos capturen y manipulen listas de argumentos. Esto permite crear utilidades que concatenan tuplas, reenvían parámetros y transforman signaturas de llamadas con total seguridad de tipos.
Capturar argumentos como una tupla
Un genérico restringido a unknown[] puede capturar una lista de argumentos completa como un tipo de tupla T, conservando el tipo y la posición de cada parámetro.
function tuple<T extends unknown[]>(...args: T): T {
return args
}
const t = tuple("a", 1, true) // type [string, number, boolean]
console.log(t)Aplicar spread a una tupla genérica
Puede aplicar spread a una tupla genérica capturada para incluirla en otra lista de parámetros. Así se reenvían los argumentos conservando sus tipos exactos.
function wrap<T extends unknown[]>(fn: (...args: T) => void) {
return (...args: T) => fn(...args)
}
const log = wrap((n: number, s: string) => console.log(n, s))
log(1, "hi")Concatenar dos tuplas
Los tipos de tupla variádicos resultan especialmente útiles al combinar tuplas. Aplicar spread a dos tuplas genéricas en el tipo de retorno produce su concatenación.
function concat<A extends unknown[], B extends unknown[]>(a: A, b: B): [...A, ...B] {
return [...a, ...b]
}
const r = concat([1, 2], ["a"]) // [number, number, string]
console.log(r)Por qué el tipo resultante es preciso
Como [...A, ...B] aplica spread a las tuplas genéricas, el resultado conserva el tipo y el orden de cada elemento, en lugar de convertirse simplemente en un array con un tipo unión ampliado.
function concat<A extends unknown[], B extends unknown[]>(a: A, b: B): [...A, ...B] {
return [...a, ...b]
}
const r = concat([true], [42])
const flag: boolean = r[0]
const num: number = r[1]
console.log(flag, num)Anteponer un argumento
Las tuplas variádicas permiten transformar listas de parámetros; por ejemplo, una función puede añadir un argumento inicial a la signatura de una función de callback.
function withId<T extends unknown[]>(fn: (...args: T) => void) {
return (id: number, ...rest: T) => {
console.log("id", id)
fn(...rest)
}
}
const f = withId((msg: string) => console.log(msg))
f(7, "hello")Extraer el tipo de la cabecera
Con un parámetro de tipo tupla, puede separar el tipo del primer elemento y el resto mediante una tupla con etiquetas, y después trabajar con cada parte.
function head<H, T extends unknown[]>(...args: [H, ...T]): H {
return args[0]
}
const h = head("first", 2, 3) // type string
console.log(h)Tipo de utilidad Parameters
El tipo integrado Parameters<F> extrae la lista de argumentos de una función como una tupla; internamente, se basa en tipos de tupla variádicos. Puede reutilizar los parámetros de una signatura en otro lugar.
function greet(name: string, age: number) {}
type GreetArgs = Parameters<typeof greet> // [string, number]
const args: GreetArgs = ["Ada", 36]
console.log(args)Reenvío con Parameters
Combine Parameters con un spread rest para crear un envoltorio que reenvíe los argumentos a una función existente con un tipado idéntico.
function add(a: number, b: number) { return a + b }
function traced(...args: Parameters<typeof add>): number {
console.log("calling add", args)
return add(...args)
}
console.log(traced(2, 3))Crear una signatura similar a curry
Las tuplas variádicas permiten crear utilidades de aplicación parcial: capture algunos argumentos ahora y espere el resto más adelante, con comprobación de tipos en todo momento.
function partial<A extends unknown[], B extends unknown[], R>(
fn: (...args: [...A, ...B]) => R,
...a: A
) {
return (...b: B) => fn(...a, ...b)
}
const addThree = (x: number, y: number, z: number) => x + y + z
const add5 = partial(addThree, 5)
console.log(add5(2, 3)) // 10Potencia y precaución
Los genéricos de tupla variádicos proporcionan herramientas precisas y reutilizables para transformar funciones: envoltorios, reenviadores y concatenadores. Son avanzados, así que recurra a ellos cuando la precisión de tipos aporte un beneficio real.
function pipe2<A extends unknown[], B, C>(
f: (...a: A) => B,
g: (b: B) => C
) {
return (...a: A) => g(f(...a))
}
const fn = pipe2((n: number) => n * 2, (n) => n + 1)
console.log(fn(5)) // 11Comprobación rápida
Compruebe cuánto entiende los genéricos de tupla variádicos.
Repaso
Los tipos de tupla variádicos permiten que los genéricos capturen listas de argumentos como tuplas y les apliquen spread en posiciones de parámetros o de retorno. Esto permite concatenar tuplas ([...A, ...B]), reenviar argumentos, separar la cabecera de la cola y realizar aplicaciones parciales, conservando siempre los tipos exactos de los elementos. Los tipos integrados como Parameters<F> se basan en el mismo mecanismo. Use estas herramientas cuando la precisión al tipar la estructura de una función compense la complejidad.
Preguntas frecuentes
¿La lección «Tipado de funciones variádicas» es gratis?
Sí — el texto completo de «Tipado de funciones variádicas» 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 «Tipado de funciones variádicas»?
Cree API flexibles con tipos de tuplas variádicas. 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 «Tipado de funciones variádicas»?
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
- Parámetros rest en funciones
- Spread en arrays y objetos
- Elementos rest en tuplas
- Tipado de funciones variádicas