Typer les fonctions variadiques
Créer des API flexibles avec des types de tuples variadiques.
Typer les fonctions variadiques est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.
Fonctions génériques variadiques
Les types de tuples variadiques permettent aux génériques de capturer et de manipuler des listes d’arguments. Cela permet de créer des utilitaires qui concatènent des tuples, transmettent des paramètres et remodèlent des signatures d’appel avec une sécurité de typage complète.
Capturer des arguments dans un tuple
Un générique contraint par unknown[] peut capturer toute une liste d’arguments sous la forme d’un type tuple T, en conservant le type et la position de chaque paramètre.
function tuple<T extends unknown[]>(...args: T): T {
return args
}
const t = tuple("a", 1, true) // type [string, number, boolean]
console.log(t)Décomposer un tuple générique
Vous pouvez décomposer un tuple générique capturé dans une autre liste de paramètres. Cela transmet les arguments tout en conservant leurs types exacts.
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")Concaténer deux tuples
Les types de tuples variadiques sont particulièrement utiles pour combiner des tuples. Décomposer deux tuples génériques dans un type de retour produit leur concaténation.
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)Pourquoi le type du résultat est précis
Comme [...A, ...B] décompose les tuples génériques, le résultat conserve le type et l’ordre de chaque élément, plutôt que de produire simplement un tableau union élargi.
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)Ajouter un argument au début
Les tuples variadiques permettent de remodeler des listes de paramètres, par exemple pour créer une fonction qui ajoute un argument initial à la signature d’une fonction de rappel.
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")Extraire le type de tête
Avec un paramètre tuple, vous pouvez séparer le type du premier élément et le reste au moyen d’un tuple étiqueté, puis traiter chaque partie.
function head<H, T extends unknown[]>(...args: [H, ...T]): H {
return args[0]
}
const h = head("first", 2, 3) // type string
console.log(h)Type utilitaire Parameters
Le type intégré Parameters<F> extrait la liste d’arguments d’une fonction sous la forme d’un tuple, lui-même fondé sur les types de tuples variadiques. Vous pouvez réutiliser les paramètres d’une signature ailleurs.
function greet(name: string, age: number) {}
type GreetArgs = Parameters<typeof greet> // [string, number]
const args: GreetArgs = ["Ada", 36]
console.log(args)Transmettre avec Parameters
Combinez Parameters avec une décomposition de reste pour créer une enveloppe qui transmet les arguments à une fonction existante avec un typage identique.
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))Construire une signature par application partielle
Les tuples variadiques permettent de créer des assistants d’application partielle : capturez certains arguments maintenant et attendez les autres plus tard, le tout avec une vérification de type.
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)) // 10Puissance et prudence
Les génériques de tuples variadiques vous offrent des outils précis et réutilisables pour façonner des fonctions : enveloppes, relais et concaténateurs. Ils sont avancés ; utilisez-les lorsque la précision du typage apporte réellement un avantage.
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)) // 11Vérification rapide
Testez votre compréhension des génériques de tuples variadiques.
Récapitulatif
Les types de tuples variadiques permettent aux génériques de capturer des listes d’arguments sous forme de tuples et de les décomposer dans des positions de paramètres ou de retour. Ils permettent la concaténation de tuples ([...A, ...B]), la transmission d’arguments, la séparation de la tête et du reste, ainsi que l’application partielle, tout en conservant les types exacts des éléments. Les types intégrés tels que Parameters<F> reposent sur le même mécanisme. Utilisez ces outils lorsque la précision du typage de la structure d’une fonction justifie leur complexité.
Questions Fréquemment Posées
La leçon « Typer les fonctions variadiques » est-elle gratuite ?
Oui — le texte complet de « Typer les fonctions variadiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Typer les fonctions variadiques » ?
Créer des API flexibles avec des types de tuples variadiques. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer TypeScript Academy ?
Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Typer les fonctions variadiques » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?
Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Paramètres rest dans les fonctions
- Opérateur spread dans les tableaux et les objets
- Éléments rest des tuples
- Typer les fonctions variadiques