otherInfo;
这里，剩余运算符告诉JavaScript程序将用户提供给参数otherInfo的任何值都添加到一个数组中。然后，将该数组赋值给otherInfo参数。
因此，我们将...otherInfo称之为剩余参数。
需要注意的是，调用时传递给函数的实参中剩余参数是可选的。
另一个例子：
// Define a function with two regular parameters and one rest parameter:
function myBio(firstName, lastName, ...otherInfo) {
return otherInfo;
// Invoke myBio function while passing five arguments to its parameters:
myBio("Oluwatobi", "Sofela", "CodeSweetly", "Web Developer", "Male");
// The invocation above will return:
["CodeSweetly", "Web Developer", "Male"]
查看运行结果
上面的代码中，调用函数myBio()时传入了5个参数，而函数myBio()的实参只有3个。也就是说，参数"Oluwatobi"和"Sofela"分别传递给了firstName和lastName，其它的参数（"CodeSweetly"，"Web Developer"和"Male"）都传递给了剩余参数otherInfo。所以，函数myBio()返回的结果是["CodeSweetly", "Web Developer", "Male"]，它们都是剩余参数otherInfo的内容。
注意！不能在包含剩余参数的函数体中使用"use strict"
记住，不能在任何包含剩余参数，默认参数，或参数解构的函数体中使用"use strict"指令。否则，JavaScript将报语法错误。
考虑下面的代码：
// Define a function with one rest parameter:
function printMyName(...value) {
"use strict";
return value;
// The definition above will return:
"Uncaught SyntaxError: Illegal 'use strict' directive in function with non-simple parameter list"
注意：只有当整个脚本或封闭作用域处于strict模式时，才可以将"use strict"放到函数体外。
现在我们知道了剩余运算符在函数中的作用，接下来我们来看看它在参数解构中是如何工作的。
剩余运算符在参数解构中是如何工作的？
剩余运算符在参数解构赋值时通常被用在最后一个变量的前面。下面是一个例子：
// Define a destructuring array with two regular variables and one rest variable:
const [firstName, lastName, ...otherInfo] = [
"Oluwatobi", "Sofela", "CodeSweetly", "Web Developer", "Male"
// Invoke the otherInfo variable:
console.log(otherInfo);
// The invocation above will return:
["CodeSweetly", "Web Developer", "Male"]
查看运行结果
这里的剩余运算符（...）告诉JavaScript程序将用户提供的其它值都添加到一个数组中。然后，将该数组赋值给otherInfo变量。
因此，我们将这里的...otherInfo称之为剩余变量。
另一个例子：
// Define a destructuring object with two regular variables and one rest variable:
const { firstName, lastName, ...otherInfo } = {
firstName: "Oluwatobi",
lastName: "Sofela",
companyName: "CodeSweetly",
profession: "Web Developer",
gender: "Male"
// Invoke the otherInfo variable:
console.log(otherInfo);
// The invocation above will return:
{companyName: "CodeSweetly", profession: "Web Developer", gender: "Male"}
查看运行结果
注意上面的代码中，剩余运算符将一个属性对象（而不是数组）赋值给otherInfo变量。也就是说，当你在解构一个对象时使用剩余运算符，它将生成一个属性对象而非数组。
但是，如果你在解构数组或函数时使用剩余运算符，它将生成数组字面量。
你应该已经注意到了，在JavaScript arguments和剩余参数之间存在一些区别，下面我们来看看这些区别都有哪些。
JavaScript arguments和剩余参数之间有哪些区别？
下面我列出了JavaScript arguments和剩余参数之间的一些区别：
区别1：arguments对象是一个类似于数组的对象，但它并非真正的数组！
请记住这一点，JavaScript arguments对象不是真正的数组。它是一个类似于数组的对象，不具备数组所拥有的任何特性。
而剩余参数是一个真正的数组，你可以在它上面使用数组所拥有的任何方法。例如，你可以对一个剩余参数使用sort()、map()、forEach()或pop()方法。但你不能对arguments对象使用这些方法。
区别2：不能在箭头函数中使用arguments对象
arguments对象在箭头函数中不可用，而剩余参数在所有的函数中都是可用的，也包括箭头函数。
区别3：优先使用剩余参数
优先使用剩余参数而不是arguments对象，特别是在编写ES6兼容代码时。
我们已经了解了剩余运算符是如何工作的，下面我们来讨论下展开运算符，并看看它和剩余运算符之间的区别。
什么是展开运算符以及它在JavaScript中是如何工作的？
展开运算符（...）将一个可迭代的对象展开为单个元素。
展开运算符可以应用在数组字面量，函数调用，以及被初始化的属性对象中，它将可迭代对象的值逐一展开到单独的元素中。实际上，它和剩余操作符正好相反。
注意，只有在数组字面量，函数调用，或被初始化的属性对象中使用展开运算符时才有效。
下面我们来看一些实际的例子。
示例1：展开运算符在数组字面量中如何工作
const myName = ["Sofela", "is", "my"];
const aboutMe = ["Oluwatobi", ...myName, "name."];
console.log(aboutMe);
// The invocation above will return:
[ "Oluwatobi", "Sofela", "is", "my", "name." ]
查看运行结果
上面的代码中，展开运算符（...）将数组myName拷贝到aboutMe中。
对myName的任何修改不会反映到aboutMe中。因为myName数组中的所有值都是原语。扩展操作符只是简单地将myName数组的内容复制并粘贴到aboutMe中，而不创建任何对原始数组元素的引用。
展开运算符只做浅拷贝。所以，当myName数组中包含任何非原语值时，JavaScript将在myName和aboutMe之间创建一个引用。有关展开运算符如何处理原语值和非原语值的更多信息，可以查看这里。
假设我们没有使用展开运算符来复制数组myName的内容，例如我们编写这行代码const aboutMe = [ "Oluwatobi", myName, "name." ] 这种情况下JavaScript将给myName分配一个引用，这样，所有对myName数组所做的修改就都会反映到aboutMe数组中。
示例2：如何使用展开运算符将字符串转换为数组
const myName = "Oluwatobi Sofela";
console.log([...myName]);
// The invocation above will return:
[ "O", "l", "u", "w", "a", "t", "o", "b", "i", " ", "S", "o", "f", "e", "l", "a" ]
查看运行结果
上面的代码中，我们在数组字面量中使用展开运算符（[...]）将myName字符串的值展开为一个数组。这样，字符串"Oluwatobi Sofela"的内容被展开到数组[ "O", "l", "u", "w", "a", "t", "o", "b", "i", " ", "S", "o", "f", "e", "l", "a" ]中。
示例3：展开运算符如何在函数调用中工作
const numbers = [1, 3, 5, 7];
function addNumbers(a, b, c, d) {
return a + b + c + d;
console.log(addNumbers(...numbers));
// The invocation above will return:
查看运行结果
上面的代码中，我们使用展开运算符将数组numbers的内容展开并传递给函数addNumbers()的参数。如果数组numbers的元素多于4个，JavaScript只会将前4个元素作为参数传递给函数addNumbers()而忽略其余的元素。
下面是一些其它的例子：
const numbers = [1, 3, 5, 7, 10, 200, 90, 59];
function addNumbers(a, b, c, d) {
return a + b + c + d;
console.log(addNumbers(...numbers));
// The invocation above will return:
查看运行结果
const myName = "Oluwatobi Sofela";
function spellName(a, b, c) {
return a + b + c;
console.log(spellName(...myName)); // returns: "Olu"
console.log(spellName(...myName[3])); // returns: "wundefinedundefined"
console.log(spellName([...myName])); // returns: "O,l,u,w,a,t,o,b,i, ,S,o,f,e,l,aundefinedundefined"
console.log(spellName({...myName})); // returns: "[object Object]undefinedundefined"
查看运行结果
示例4：展开运算符在对象字面量中如何工作
const myNames = ["Oluwatobi", "Sofela"];
const bio = { ...myNames, runs: "codesweetly.com" };
console.log(bio);
// The invocation above will return:
{ 0: "Oluwatobi", 1: "Sofela", runs: "codesweetly.com" }
查看运行结果
上面的代码中，我们在bio对象内部使用展开运算符将数组myNames的值展开为各个属性。
有关展开运算符我们需要知道的
当使用展开运算符时，请记住以下三个基本信息。
1. 展开运算符不能展开对象字面量的值
由于属性对象是非可迭代对象，所以不能使用展开运算符将它的值进行展开。但是，你可以使用展开运算符将一个对象的属性克隆到另一个对象中。
看下面这个例子：
const myName = { firstName: "Oluwatobi", lastName: "Sofela" };
const bio = { ...myName, website: "codesweetly.com" };
console.log(bio);
// The invocation above will return:
{ firstName: "Oluwatobi", lastName: "Sofela", website: "codesweetly.com" };
查看运行结果
上面的代码中，我们使用展开运算符将myName对象的内容克隆到了bio对象中。
展开运算符只能展开可迭代对象的值。
只有当一个对象包含一个带有@@iterator key的属性时，才是一个可迭代的对象。
Array，TypedArray，String，Map，Set都是内置的可迭代类型，因为它们默认都带有@@iterator属性。
属性对象是非可迭代数组类型，因为默认情况下它没有@@iterator属性。
可以在属性对象上添加@@iterator使其成为可迭代对象。
2. 展开运算符不克隆相同的属性
假设我们使用展开运算符将对象A的属性克隆到对象B中，如果对象B包含与对象A中相同的属性，那么对象B的属性将覆盖对象A的属性。换句话说，在这个过程中，对象A中那些与对象B相同的属性不会被克隆。
看下面这个例子：
const myName = { firstName: "Tobi", lastName: "Sofela" };
const bio = { ...myName, firstName: "Oluwatobi", website: "codesweetly.com" };
console.log(bio);
// The invocation above will return:
{ firstName: "Oluwatobi", lastName: "Sofela", website: "codesweetly.com" };
查看运行结果
注意，展开运算符没有将myName对象的firstName属性的值复制到bio对象中，因为对象bio中已经包含firstName属性了。
3. 注意展开运算符在包含非原语的对象中是何如工作的
如果在只包含原语值的对象（或数组）上使用展开运算符，JavaScript不会在原对象和复制对象之间创建任何引用。
看下面这段代码：
const myName = ["Sofela", "is", "my"];
const aboutMe = ["Oluwatobi", ...myName, "name."];
console.log(aboutMe);
// The invocation above will return:
["Oluwatobi", "Sofela", "is", "my", "name."]
查看运行结果
注意，myName中的每一个元素都是一个原语值，因此，当我们使用展开运算符将myName克隆到aboutMe时，JavaScript不会在两个数组之间创建任何引用。所以，对myName数组所做的任何修改都不会反映到aboutMe数组中，反之亦然。
让我们给myName数组添加一个元素：
myName.push("real");
现在我们来检查一下myName和aboutMe的值：
console.log(myName); // ["Sofela", "is", "my", "real"]
console.log(aboutMe); // ["Oluwatobi", "Sofela", "is", "my", "name."]
请注意，我们对myName数组的修改并没有反映到aboutMe数组中，因为展开运算符并没有在原始数组和复制数组之间创建任何引用。
如果myName数组包含非原语项呢？
假设myName包含非原语项，这种情况下，展开运算符将在原数组的非原语项和克隆项之间创建一个引用。
看下面的例子：
const myName = [["Sofela", "is", "my"]];
const aboutMe = ["Oluwatobi", ...myName, "name."];
console.log(aboutMe);
// The invocation above will return:
[ "Oluwatobi", ["Sofela", "is", "my"], "name." ]
查看运行结果
注意，这里的myName数组包含一个非原语项。
因此，当使用展开运算符将myName的内容克隆到aboutMe时，JavaScript将在两个数组之间创建一个引用。这样，任何对myName数组的修改都会反映到aboutMe数组中，反之亦然。
作为例子，我们同样给myName数组添加一个元素：
myName[0].push("real");
现在我们来查看myName和aboutMe的值：
console.log(myName); // [["Sofela", "is", "my", "real"]]
console.log(aboutMe); // ["Oluwatobi", ["Sofela", "is", "my", "real"], "name."]
查看运行结果
注意，对myName数组的修改内容反映到了aboutMe数组中，因为展开运算符在原始数组和复制数组之间创建了一个引用。
另外一个例子：
const myName = { firstName: "Oluwatobi", lastName: "Sofela" };
const bio = { ...myName };
myName.firstName = "Tobi";
console.log(myName); // { firstName: "Tobi", lastName: "Sofela" }
console.log(bio); // { firstName: "Oluwatobi", lastName: "Sofela" }
查看运行结果
上面的代码中，myName的更新内容没有反映到bio对象中，因为我们在只包含原语值的对象上使用展开运算符。
注意，开发人员通常将这里的myName称之为浅对象，因为它只包含原语项。
另外一个例子：
const myName = {
fullName: { firstName: "Oluwatobi", lastName: "Sofela" }
const bio = { ...myName };
myName.fullName.firstName = "Tobi";
console.log(myName); // { fullName: { firstName: "Tobi", lastName: "Sofela" } }
console.log(bio); // { fullName: { firstName: "Tobi", lastName: "Sofela" } }
查看运行结果
上面的代码中，myName的更新内容被反映到bio对象中，因为我们在包含非原语值的对象上使用了展开运算符。
我们称这里的myName为深对象，因为它包含非原语项。
将一个对象克隆到另一个对象时，如果创建了引用，则进行的是浅拷贝。例如，...myName产生了myName对象的一个浅拷贝，因为你对其中一个对象所做的任何修改都会反映到另一个对象中。
将一个对象克隆到另一个对象时，如果没有创建引用，则进行的时深拷贝。例如，我可以通过const bio = JSON.parse(JSON.stringify(myName))将myName对象深拷贝到bio对象中。如此一来，JavaScript将把myName克隆到bio中而不创建任何引用。
我们可以通过用一个新对象来替换myName或bio中的fullName子对象，从而切断myName和bio之间的引用。例如，使用myName.fullName = { firstName: "Tobi", lastName: "Sofela" }来断开myName和bio之间的指针。
本文讨论了剩余操作符和展开操作符之间的区别，并通过示例说明了它们在JavaScript中是如何工作的。
原文地址：https://www.freecodecamp.org/news/javascript-rest-vs-spread-operators/
