0Pricing
TypeScript Academy · Leçon

Paramètres rest dans les fonctions

Typer des fonctions qui acceptent un nombre quelconque d’arguments.

Paramètres rest dans les fonctions est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 avec de nombreux arguments

Les paramètres de reste permettent à une fonction d'accepter un nombre quelconque d'arguments, rassemblés dans un seul tableau. TypeScript type ce tableau, ce qui vous garantit une vérification sûre même avec des appels de longueur variable.

Paramètre de reste élémentaire

Préfixez le dernier paramètre avec ... et attribuez-lui un type tableau. À l'intérieur de la fonction, il se comporte comme un tableau ordinaire.

function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0)
}
console.log(sum(1, 2, 3, 4)) // 10

Appeler sans argument

Un paramètre de reste peut correspondre à zéro argument : le tableau est simplement vide. Aucun traitement particulier n'est nécessaire lorsqu'il n'y a pas d'argument.

function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0)
}
console.log(sum()) // 0

Reste après des paramètres fixes

Un paramètre de reste peut suivre des paramètres fixes, mais il doit être dernier. Les paramètres fixes sont liés en premier ; tout ce qui reste va dans le tableau de reste.

function join(separator: string, ...parts: string[]): string {
  return parts.join(separator)
}
console.log(join("-", "a", "b", "c")) // a-b-c

Un seul reste, toujours en dernier

Vous pouvez avoir au maximum un paramètre de reste, et aucun élément ne peut le suivre. Placer un paramètre après le reste constitue une erreur de syntaxe.

// function bad(...nums: number[], last: number) {} // Error
function ok(first: number, ...rest: number[]) {
  return first + rest.length
}
console.log(ok(10, 1, 2)) // 12

Contraintes de type des éléments

Le type des éléments du tableau de reste impose une contrainte à chaque argument. Le passage d'un type incorrect est détecté lors de la compilation.

function tags(...labels: string[]): string {
  return labels.join(",")
}
console.log(tags("a", "b"))
// tags("a", 5) // Error: 5 is not a string

Reste avec un type union

Le type des éléments peut être une union, ce qui autorise des arguments de types différents. À l'intérieur, affinez le type de chaque élément avant de l'utiliser.

function show(...items: (string | number)[]): string {
  return items.map(String).join(" ")
}
console.log(show("x", 1, "y", 2)) // x 1 y 2

Reste avec des types tuple

Un paramètre de reste peut être typé comme un tuple pour décrire une forme composée d'éléments fixes suivis d'éléments variables. Ici, le premier argument est une chaîne, suivie d'un nombre quelconque de nombres.

function record(...args: [string, ...number[]]): string {
  const [label, ...values] = args
  return label + ": " + values.join(",")
}
console.log(record("scores", 9, 8, 7))

Le reste tuple impose l'arité

Avec un type de reste tuple, les éléments initiaux sont obligatoires. Omettre le premier argument obligatoire provoque une erreur de compilation — c'est plus strict qu'un simple tableau.

function record(...args: [string, ...number[]]): number {
  return args.length
}
console.log(record("x")) // 1
// record() // Error: missing string argument

Décomposer un tableau dans un appel avec reste

Vous pouvez transmettre un tableau existant à un paramètre de reste en utilisant la décomposition au moment de l'appel. Le type des éléments du tableau doit correspondre à celui du paramètre.

function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0)
}
const values = [1, 2, 3]
console.log(sum(...values)) // 6

Le reste en pratique

Les paramètres de reste sont utiles pour les fonctions auxiliaires de journalisation, les formateurs et les utilitaires mathématiques — bref, pour tout ce qui traite un nombre variable d'entrées avec un type commun ou structuré.

function max(first: number, ...rest: number[]): number {
  return rest.reduce((m, n) => (n > m ? n : m), first)
}
console.log(max(3, 7, 2, 9, 1)) // 9

Vérification rapide

Testez votre compréhension des paramètres de reste typés.

Récapitulatif

Les paramètres de reste utilisent ... sur le dernier paramètre pour rassembler les arguments supplémentaires dans un tableau typé. Ils doivent être placés en dernier et il ne peut y en avoir qu'un seul. Typez-les comme un tableau simple, un tableau d'union ou un tuple pour exprimer des formes composées d'éléments fixes puis variables, qui imposent l'arité. Décomposez un tableau existant au moment de l'appel pour alimenter un paramètre de reste.

Questions Fréquemment Posées

La leçon « Paramètres rest dans les fonctions » est-elle gratuite ?

Oui — le texte complet de « Paramètres rest dans les fonctions » 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 « Paramètres rest dans les fonctions » ?

Typer des fonctions qui acceptent un nombre quelconque d’arguments. 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 1 sur 4.

Combien de temps prend la leçon « Paramètres rest dans les fonctions » ?

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

  1. Paramètres rest dans les fonctions
  2. Opérateur spread dans les tableaux et les objets
  3. Éléments rest des tuples
  4. Typer les fonctions variadiques
← Retour à TypeScript Academy