The Rest parameter allows multiple parameters to be collected into an array, simplifying the writing of functions that handle uncertain number of parameters. For example, using...numbers in the sum function can capture all parameters and process them as an array, and then sum them using methods such as reduce; unlike the arguments object, the rest parameter is a real array and only contains unnamed parameters; in addition, the rest parameter must be at the last position of the function parameter list. 1. Use the... syntax to collect parameters into an array. 2. You can directly apply map, filter and other array methods. 3. The rest parameter must be placed at the end of the parameter list.

Rest parameters in JavaScript are a way to represent an indefinite number of arguments as an array. This feature is super handy when you're writing functions that need to accept a variable number of inputs.

Using Rest Parameters in Functions

When you use the rest parameter syntax ( ...parameterName ), it collects all remaining arguments into a real array. This makes it easier to work with them using array methods like map , filter , or reduce .

For example:

 function sum(...numbers) {
  return numbers.reduce((total, num) => total num, 0);
}

console.log(sum(1, 2, 3)); // Output: 6

Here's what happens:

• The rest parameter ...numbers captures all the arguments passed to the function.
• It turns them into a proper array called numbers .
• You can then use .reduce() to add them up without any hassle.

This is really useful when you don't know how many values ??someone will pass into your function.

Difference Between Rest Parameters and arguments

It's easy to confuse rest parameters with the older arguments object in JavaScript.

The main differences are:

• arguments isn't a real array — it's an array-like object, so you can't directly use array methods on it.
• Rest parameters are actual arrays, which means you can do things like map or filter right away.
• The arguments object includes all arguments passed to the function, while rest parameters only include the ones that don't have their own named parameter.

So if you're writing modern JavaScript, rest parameters are usually the better choice for handling multiple inputs.

Rest Parameters Must Be the Last Parameter

One important rule: the rest parameter has to be the last one in the function definition. Otherwise, JavaScript won't know where the rest begins.

For example:

 function logItems(prefix, ...items) {
  console.log(prefix, items);
}

In this case:

• The first argument becomes prefix
• All remaining arguments are collected into the items array

But if you try to do something like this:

 function badExample(...items, suffix) { // Syntax error!
  // ...
}

You'll get an error because rest parameters can't come before other named parameters.

Summary

So to recap quickly:

• Rest parameters let you capture multiple arguments into an array.
• They're more flexible and powerful than the old arguments object.
• Always place them at the end of your function's parameter list.

Basically that's it.

The above is the detailed content of What are rest parameters in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!