这就是属性展开符号。它是在ES2018年添加的(扩展数组/可迭代对象是更早的ES2015年)，但它在React项目中已经通过编译(作为“JSX扩展属性”，尽管你也可以在其他地方做，而不仅仅是属性)得到了很长时间的支持。

{……。props}将props中的“自己的”可枚举属性展开为您正在创建的Modal元素上的离散属性。例如，如果这个。道具包含a: 1和b: 2

<Modal {...this.props} title='Modal heading' animation={false}>

会和

<Modal a={this.props.a} b={this.props.b} title='Modal heading' animation={false}>

但它是动态的，所以道具中任何“自己的”属性都包括在内。

由于儿童是道具中“自己”的属性，传播将包括它。如果这个出现的组件有子元素，它们会被传递给Modal。在开始标记和结束标记之间放置子元素只是语法上的“糖”——好的那种——用于在开始标记中放置子属性。例子:

实例扩展React。组件{ 呈现(){ const {className, children} = this.props; 回报( < div className = {className} > {孩子} < / div > ）; ｝ ｝ ReactDOM.render ( ［ > <例子className =“第一” <span>第一个子元素</span> < / >示例, <示例className="second" children={<span> second中的子</span>} /> ), . getelementbyid(“根”) ）; 当代{ 颜色:绿色; ｝ 接着{ 颜色:蓝色; ｝ < div id = "根" > < / div > < script src = " https://cdnjs.cloudflare.com/ajax/libs/react/16.6.3/umd/react.production.min.js " > < /脚本> < script src = " https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.6.3/umd/react-dom.production.min.js " > < /脚本>

扩展表示法不仅在这个用例中很方便，而且在创建一个具有现有对象的大部分(或全部)属性的新对象时也很方便——当你更新状态时经常会出现这种情况，因为你不能直接修改状态:

this.setState(prevState => {
    return {foo: {...prevState.foo, a: "updated"}};
});

这将this.state.foo替换为一个新对象，该对象具有与foo相同的所有属性，除了a属性，它变成了“updated”:

Const obj = { foo: { 答:1, b: 2 c: 3 ｝ }; console.log(“原始”,obj.foo); //创建一个新对象并将其赋值给' obj.foo ' obj。Foo ={…Foo, a: "updated"}; obj.foo console.log(“更新”); .as-console-wrapper { Max-height: 100%重要; ｝

JavaScript中的三个点是展开/休息操作符。

传播算子

扩展语法允许在需要多个参数的地方展开表达式。

myFunction(...iterableObj);

[...iterableObj, 4, 5, 6]

[...Array(10)]

其他参数

rest形参语法用于参数数量可变的函数。

function(a, b, ...theArgs) {
  // ...
}

数组的展开/休息操作符是在ES6中引入的。有一个关于对象扩展/休息属性的状态2提案。

TypeScript还支持扩展语法，并可以将其转换为较旧版本的ECMAScript，但存在一些小问题。

这三个点(…)被称为展开运算符，这在概念上类似于ES6数组展开运算符JSX 利用这些支持并开发标准，以便在JSX中提供更清晰的语法

对象初始化器中的展开属性复制自己的枚举对象 属性从提供的对象转移到新创建的对象。 设n = {x, y，…z}; n;// {x: 1, y: 2, a: 3, b: 4}

引用:

传播特性 JSX深入

．.． 被称为扩展属性，顾名思义，它允许表达式展开。

var parts = ['two', 'three'];
var numbers = ['one', ...parts, 'four', 'five']; // ["one", "two", "three", "four", "five"]

在这种情况下(我要化简它)

// Just assume we have an object like this:
var person= {
    name: 'Alex',
    age: 35 
}

这样的:

<Modal {...person} title='Modal heading' animation={false} />

等于

<Modal name={person.name} age={person.age} title='Modal heading' animation={false} />

简而言之，我们可以说这是一条简洁的捷径。

这是ES6的一个特性，在React中也使用了这个特性。请看下面的例子:

function Sum(x, y, z) {
   return x + y + z;
}
console.log(Sum(1, 2, 3)); // 6

如果我们最多有三个参数，这种方式很好。但是，如果我们需要添加，例如，110个参数。我们是否应该定义它们并逐个添加它们?

当然，有一种更简单的方法，叫做扩散。 而不是传递所有这些参数，你写:

function (...numbers){} 

我们不知道有多少参数，但我们知道有很多。

基于ES6，我们可以重写上面的函数如下所示，并使用它们之间的扩展和映射，使其变得简单如一块蛋糕:

let Sum = (...numbers) => {
    return numbers.reduce((prev, current) => prev + current);
}
console.log(Sum(1, 2, 3, 4, 5, 6, 7, 8, 9)); // 45

对于那些来自Python世界的人来说，JSX扩展属性相当于 解包参数列表(Python **-操作符)。

我知道这是一个JSX问题，但使用类比有时有助于更快地得到答案。

它只是在JSX中以不同的方式为您定义道具!

它使用…ES6中的数组和对象操作符(对象1还不完全支持)，所以基本上如果你已经定义了你的props，你可以通过这种方式将它传递给你的元素。

所以在你的例子中，代码应该是这样的:

function yourA() {
  const props = {name='Alireza', age='35'};
  <Modal {...props} title='Modal heading' animation={false} />
}

因此，您定义的道具现在分开了，并可以在必要时重用。

它等于:

function yourA() {
  <Modal name='Alireza' age='35' title='Modal heading' animation={false} />
}

以下是React团队对JSX中扩展操作符的引用:

JSX传播属性 如果您知道要放在组件上的所有属性 提前使用JSX是很容易的:

var component = <Component foo={x} bar={y} />;

如果你不知道你想要设置哪些属性，你可能会想稍后将它们添加到对象上:

var component = <Component />;
component.props.foo = x; // bad
component.props.bar = y; // also bad

这是一个反模式，因为这意味着我们不能帮你检查 正确的propTypes直到很久以后。这意味着你的propTypes 错误将以一个神秘的堆栈跟踪结束。 这些道具应该被认为是不可变的。改变道具对象 其他地方可能会导致意想不到的后果，所以理想情况下会是这样 在这一点上是一个冻结的物体。 现在你可以使用JSX的一个新特性，叫做扩展属性:

var props = {};
    props.foo = x;
    props.bar = y;
    var component = <Component {...props} />;

对象的属性被复制到 组件的道具。 您可以多次使用该属性，也可以将其与其他属性组合使用。 规范顺序很重要。稍后的属性覆盖 之前的。

var props = { foo: 'default' };
var component = <Component {...props} foo={'override'} />;
console.log(component.props.foo); // 'override'

奇怪的是什么…符号?…操作符(或展开操作符)在ES6中已经支持数组。也有 对象Rest和扩展属性的ECMAScript提案。我们 利用这些支持并有序地开发标准 在JSX中提供更清晰的语法。

这些被称为价差。顾名思义，它的意思是把它的值放到那些数组或对象中。

如:

let a = [1, 2, 3];
let b = [...a, 4, 5, 6];
console.log(b);
> [1, 2, 3, 4, 5, 6]

…(展开运算符)用于React to:

提供一种简洁的方式将道具从父组件传递给子组件。例如，给定父组件中的这些道具，

this.props = {
  username: "danM",
  email: "dan@mail.com"
}

它们可以通过以下方式传递给孩子，

<ChildComponent {...this.props} />

哪个和这个相似

<ChildComponent username={this.props.username} email={this.props.email} />

但要干净得多。

三个点代表ES6中的展开运算符。它允许我们在JavaScript中做很多事情:

连接数组 var shooterGames =['使命召唤'，'孤岛惊魂'，'生化危机']; var racingGames =['极品飞车'，' gt赛车'，'Burnout']; Var游戏=[…]shooterGames……玩赛车); console.log(games) //['使命召唤'，'孤岛惊魂'，'生化危机'，'极品飞车'，' gt赛车'，'Burnout'] 析构数组 var shooterGames =['使命召唤'，'孤岛惊魂'，'生化危机']; Var[首先，…剩余]= shooterGames; console.log(第一);//使命召唤 console.log(剩余的);//[《孤岛惊魂》、《生化危机》] 组合两个对象 var myCrush = { 名字:“萨琳娜”, middlename:“玛丽” }; Var lastname = '我的姓'; var myWife = { ……myCrush, 姓 ｝ console.log (myWife);// {firstname: 'Selena'， // midlename: 'Marie'， // lastname: '我的姓'}

这三个点还有另一个用途，就是所谓的Rest参数，它可以将一个函数的所有参数作为一个数组。

作为数组的函数参数 函数fun1(…参数){ ｝

它被称为JavaScript中的扩展语法。

它在JavaScript中用于解构数组或对象。

例子:

const objA = { a: 1, b: 2, c: 3 }
const objB = { ...objA, d: 1 }
/* Result of objB will be { a: 1, b: 2, c: 3, d: 1 } */
console.log(objB)

const objC = { ....objA, a: 3 }
/* result of objC will be { a: 3, b: 2, c: 3, d: 1 } */
console.log(objC)

你可以用JavaScript中的Object.assign()函数得到相同的结果。

参考:扩展语法

在React应用程序中传递道具是常见的做法。这样我们就可以将状态更改应用到子组件上，而不管它是纯的还是不纯的(无状态的还是有状态的)。在传递道具时，有时最好的方法是传递单个属性或整个属性对象。由于ES6中对数组的支持，我们得到了“…”符号，现在我们能够实现将整个对象传递给子对象。

将道具传递给子对象的典型过程如下所示:

var component = <Component foo={x} bar={y} />;

当道具数量很少时可以使用这种方法，但当道具数量过多时就无法管理了。当您不知道子组件中所需的属性，而典型的JavaScript方法是简单地设置这些属性并稍后绑定到对象时，此方法就会出现问题。这会导致propType检查和神秘堆栈跟踪错误的问题，这些问题没有帮助，并导致调试延迟。下面是这种做法的一个例子，以及不应该做的事情:

var component = <Component />;
component.props.foo = x; // bad
component.props.bar = y;

这样做可以达到同样的结果，但会取得更适当的成功:

var props = {};
props.foo = x;
props.bar = y;
var component = Component(props); // Where did my JSX go?

但不使用JSX spread或JSX，所以要将其循环回方程中，我们现在可以这样做:

var props = {};
props.foo = x;
props.bar = y;
var component = <Component {...props} />;

包含在“…props"是foo: x, bar: y.这可以与其他属性结合起来覆盖"…使用这种语法:

var props = { foo: 'default' };
var component = <Component {...props} foo={'override'} />;
console.log(component.props.foo); // 'override'

此外，我们还可以将其他属性对象复制到其他对象上，或者按以下方式组合它们:

var oldObj = { foo: 'hello', bar: 'world' };
var newObj = { ...oldObj, foo: 'hi' };
console.log(newObj.foo); // 'hi';
console.log(newObj.bar); // 'world';

或者像这样合并两个不同的对象(这还没有在所有react版本中使用):

var ab = { ...a, ...b }; // merge(a, b)

根据Facebook的react/docs网站，另一种解释是:

如果您已经将“props”作为对象，并且希望在JSX中传递它，则可以使用“…”作为SPREAD操作符来传递整个props对象。下面两个例子是等价的:

function App1() {
  return <Greeting firstName="Ben" lastName="Hector" />;
}



function App2() {
  const props = {firstName: 'Ben', lastName: 'Hector'};
  return <Greeting {...props} />;
}

在构建泛型容器时，扩展属性可能很有用。然而，它们也会使代码变得混乱，因为很容易将许多不相关的道具传递给不关心它们的组件。应该谨慎使用此语法。

三点……表示展开运算符或休息参数。

它允许数组表达式或字符串或任何可以迭代的东西在函数调用的参数为零或多个，或数组的元素为预期的地方展开。

合并两个数组

Var arr1 = [1,2,3]; Var arr2 = [4,5,6]; Arr1 =[…arr1……arr2); console.log (arr1);//[1,2,3,4,5,6]

复制数组:

Var arr = [1,2,3]; Var arr2 =[…arr]; console.log (arr);//[1,2,3]

注意:扩展语法在复制对象时有效地深入一层 数组中。因此，它可能不适合复制多维 数组，如下例所示(与 Object.assign()和spread语法)。

将一个数组的值添加到另一个数组的特定索引处。

Var arr1 = [4,5] Var arr2 =[1,2,3，…]arr1, 6] console.log (arr2);// [1,2,3,4,5,6]

使用new调用构造函数时:

var dateFields = [1970, 0,1];// 1 1970年1月 var d = new Date(…dateFields); console.log (d);

在对象字面量中展开:

var obj1 = {foo: 'bar'， x: 42}; var obj2 = {foo: 'ba '， y: 13}; var clonedObj ={…obj1}; console.log (clonedObj);// {foo: "bar"， x: 42} var mergedObj ={…}obj1, ...obj2}; console.log (mergedObj);// {foo: "baz"， x: 42, y: 13}

注意obj1的foo属性已经被obj2的foo属性所覆盖。

作为一种rest形参语法，它允许我们将无限数量的实参表示为数组:

函数sum(…theArgs) { theArgs返回。Reduce ((previous, current) => { 返回先前+当前; })； ｝ Console.log (sum(1,2,3));/ / 6 Console.log (sum(1,2,3,4));/ / 10

注意:spread语法(除了spread属性的情况)只能应用于可迭代对象:

所以下面的语句会抛出一个错误:

var obj = {'key1'： 'value1'}; var 数组 = [...卷];类型错误：obj 不可迭代

Reference1

Reference2

在ECMAScript 6 (ES6)中引入的展开运算符(三重运算符)。ECMAScript (ES6)是JavaScript的包装器。

props中的展开运算符可枚举属性。

这一点。道具= ｛ 名字:“丹”, 姓:“阿布拉莫夫”, 城市:纽约， :“美国” ｝ <模态{…这个。props} title='Modal heading' animation={false}>

{……。props} = {firstName: 'Dan'， 姓:“阿布拉莫夫”, 城市:纽约， 国家:“美国”}

但是主特征展开运算符用于引用类型。

例如,

let person= {
    name: 'Alex',
    age: 35
}
person1 = person;

person1.name = "Raheel";

console.log( person.name); // Output: Raheel

这称为引用类型。一个对象影响其他对象，因为它们在内存中是可共享的。如果你正在获得一个值，独立意味着扩展内存，两者都使用扩展操作符。

 let person= {
        name: 'Alex',
        age: 35
    }
person2 = {...person};

person2.name = "Shahzad";

console.log(person.name); // Output: Alex

向Brandon Morelli致敬。他在这里解释得很好，但链接可能会消失，所以我只是粘贴下面的内容:

扩展语法就是三个点:… 它允许迭代对象在需要0+参数的地方展开。 没有上下文的定义很难。让我们探索一些不同的用例来帮助理解这意味着什么。

例1 -插入数组

看看下面的代码。在这段代码中，我们没有使用spread语法:

Var mid = [3,4]; Var arr = [1,2, mid, 5,6]; console.log (arr);

上面，我们已经创建了一个名为mid的数组，然后我们创建了第二个包含我们的mid数组的数组。最后，我们登出结果。你希望arr打印什么?点击上面的运行看看会发生什么。输出如下:

[1, 2, [3, 4], 5, 6]

这是你预期的结果吗?

通过将mid数组插入到arr数组中，我们就得到了一个数组中的一个数组。如果这是我们的目标，那也没关系。但是如果您只想要一个值从1到6的数组呢?要做到这一点，我们可以使用spread语法!请记住，展开语法允许数组的元素展开。

让我们看看下面的代码。一切都是一样的-除了我们现在使用spread语法将mid数组插入到arr数组中:

Var mid = [3,4]; Var arr =[1,2，…]Mid, 5,6]; console.log (arr);

当你点击运行按钮时，结果是这样的:

[1, 2, 3, 4, 5, 6]

太棒了!

还记得刚才读到的扩展语法定义吗?这就是它发挥作用的地方。如你所见，当我们创建arr数组并在中间数组上使用展开运算符时，中间数组不仅被插入，还会展开。这种展开意味着中间数组中的每个元素都被插入到arr数组中。结果不是嵌套数组，而是一个从1到6的数字数组。

例2 -数学

JavaScript有一个内置的数学对象，允许我们进行一些有趣的数学计算。在本例中，我们将查看Math.max()。如果您不熟悉，Math.max()返回0或多个数字中最大的一个。下面是一些例子:

Math.max();
// -Infinity
Math.max(1, 2, 3);
// 3
Math.max(100, 3, 4);
// 100

如您所见，如果要找到多个数字的最大值，Math.max()需要多个参数。不幸的是，您不能简单地使用单个数组作为输入。在使用扩展语法之前，在数组上使用Math.max()最简单的方法是使用.apply()。

Var arr = [2,4,8,6,0]; 函数max(arr) { Math.max返回。应用(null, arr); ｝ console.log (max (arr));

它很管用，只是真的很烦人。

现在看看我们如何用spread语法做同样的事情:

Var arr = [2,4,8,6,0]; var max = Math.max(…arr); console.log (max);

我们不需要创建函数并利用apply方法返回Math.max()的结果，只需要两行代码!扩展语法展开数组元素，并将数组中的每个元素分别输入Math.max()方法!

例3 -复制Array

在JavaScript中，不能通过将新变量设置为已经存在的数组来复制数组。考虑下面的代码示例:

Var arr = ['a'， 'b'， 'c']; Var arr2 = arr; console.log (arr2);

当你按下run，你会得到以下输出:

['a', 'b', 'c']

现在，乍一看，它看起来是可行的-看起来我们已经把arr的值复制到arr2中。但事实并非如此。你看，在JavaScript中处理对象(数组是对象的一种类型)时，我们通过引用而不是通过值赋值。这意味着arr2被分配给了与arr相同的引用。换句话说，我们对arr2所做的任何事情也会影响原始的arr数组(反之亦然)。看看下面的内容:

Var arr = ['a'， 'b'， 'c']; Var arr2 = arr; arr2.push (' d '); console.log (arr);

上面，我们将一个新元素d放入arr2中。然而，当我们注销arr的值时，你会看到d的值也被添加到该数组中:

['a', 'b', 'c', 'd']

不过没必要害怕!我们可以使用扩展运算符! 考虑下面的代码。几乎和上面一样。相反，我们在一对方括号中使用了展开操作符:

Var arr = ['a'， 'b'， 'c']; Var arr2 =[…arr]; console.log (arr2);

点击运行，你将看到预期的输出:

['a', 'b', 'c']

上面，arr中的数组值扩展为单独的元素，然后赋值给arr2。现在我们可以随心所欲地改变arr2数组，而不会对原始的arr数组产生任何影响:

Var arr = ['a'， 'b'， 'c']; Var arr2 =[…arr]; arr2.push (' d '); console.log (arr);

同样，这是因为arr的值被展开以填充arr2数组定义的括号。因此，我们将arr2设置为等于arr的各个值，而不是像第一个例子中那样设置为对arr的引用。

奖励示例-字符串到数组

作为有趣的最后一个示例，您可以使用spread语法将字符串转换为数组。只需在一对方括号内使用spread语法:

var str = “hello”; var chars = [...p]; 控制台.log（字符）;

．.． (JavaScript中的三个点)被称为扩展语法或扩展操作符。这允许一个可迭代对象(如数组表达式或字符串)被展开，或一个对象表达式被展开。这不是React特有的。它是一个JavaScript操作符。

这里所有的答案都是有用的，但我想列出最常用的传播语法(传播操作符)的实际用例。

1. 组合数组(串联数组)

组合数组的方法有很多种，但展开操作符允许您将其放置在数组中的任何位置。如果你想组合两个数组，并将元素放置在数组中的任何位置，你可以这样做:

var arr1 = ['two', 'three'];
var arr2 = ['one', ...arr1, 'four', 'five'];

// arr2 = ["one", "two", "three", "four", "five"]

2. 复制数组

当我们想要一个数组的副本时，我们使用array .prototype.slice()方法。但是，你也可以用展开运算符做同样的事情。

var arr = [1,2,3];
var arr2 = [...arr];
// arr2 = [1,2,3]

3.调用没有应用的函数

在ES5中，要将两个数字的数组传递给doStuff()函数，你经常使用function .prototype.apply()方法，如下所示:

function doStuff (x, y, z) {}
var args = [0, 1, 2];

// Call the function, passing args
doStuff.apply(null, args);

但是，通过使用展开操作符，可以将数组传递给函数。

doStuff(...args);

4. 解构数组

你可以使用解构和rest操作符一起将信息提取到你想要的变量中:

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
console.log(x); // 1
console.log(y); // 2
console.log(z); // { a: 3, b: 4 }

5. 函数参数作为Rest参数

ES6还有三个点(…)，它表示一个rest形参，将函数的所有剩余参数收集到一个数组中。

function f(a, b, ...args) {
  console.log(args);
}

f(1, 2, 3, 4, 5); // [3, 4, 5]

6. 使用数学函数

任何将spread用作实参的函数都可以被接受任意数量实参的函数使用。

let numbers = [9, 4, 7, 1];
Math.min(...numbers); // 1

7. 两个对象合并

您可以使用展开运算符来合并两个对象。这是一种简单明了的方法。

var carType = {
  model: 'Toyota',
  yom: '1995'
};

var carFuel = 'Petrol';

var carData = {
  ...carType,
  carFuel
}

console.log(carData);
// {
//  model: 'Toyota',
//  yom: '1995',
//  carFuel = 'Petrol'
// }

8. 将字符串分离为单独的字符

您可以使用展开运算符将字符串展开为单独的字符。

let chars = ['A', ...'BC', 'D'];
console.log(chars); // ["A", "B", "C", "D"]

您可以想到更多使用扩展操作符的方法。我在这里列出的是它的流行用例。

对于那些想要简单快速理解这个问题的人:

首先，这不仅仅是React的语法。这是ES6中的扩展语法，它迭代(合并，添加等)数组和对象。点击这里阅读更多信息。

为了回答这个问题:

让我们想象你有这样的标签:

<UserTag name="Supun" age="66" gender="male" />

然后你这样做:

const user = {
  "name": "Joe",
  "age": "50"
  "test": "test-val"
};

<UserTag name="Supun" gender="male"  {...user} age="66" />

那么标签将等于这个:

<UserTag name="Joe" gender="male" test="test-val" age="66" />

因此，当你在React标签中使用spread语法时，它将标签的属性作为对象属性，与给定的对象用户合并(如果存在则替换)。此外，您可能已经注意到，它只替换属性之前，而不是属性之后。所以在这个例子中，年龄保持不变。

Spread操作符允许您将可迭代对象(如对象、字符串或数组)展开为其元素，而Rest操作符则相反，将一组元素缩减为一个数组。

扩展语法允许像数组和对象这样的数据结构进行解构 它们可以从中提取一个值，也可以为它们添加一个值。 如 Const obj={name:"ram"，age:10 从上面的例子中，我们可以说我们解构了obj并从该对象中提取了name。 同样的, const newObj ={……obj,地址:“尼泊尔”} 从这个例子中，我们向该对象添加了一个新属性。 在数组的情况下也是类似的。

传播算子!由于大多数人已经优雅地回答了这个问题，我想建议一个快速使用扩散操作符的方法列表:

…spread运算符对JavaScript中许多不同的常规任务都很有用，包括:

复制数组 连接或组合数组 使用数学函数 使用数组作为参数 向列表中添加项 在React中添加状态 结合对象 将NodeList转换为数组

查看文章了解更多细节。如何使用展开运算符。我建议你习惯它。有很多很酷的方法可以使用展开运算符。

．.． 3个点代表JS中的展开运算符。

没有展开运算符。

let a = ['one','one','two','two'];
let unq = [new Set(a)];

console.log(a);
console.log(unq);

输出:

(4) ['one', 'one', 'two', 'two']
[Set(2)]

带有展开运算符。

let a = ['one','one','two','two'];
let unq = [...new Set(a)];

console.log(a);
console.log(unq);

输出:

(4) ['one', 'one', 'two', 'two']
(2) ['one', 'two']

那三个点…不是React术语。这些是JavaScript ES6扩展操作符。这有助于在不影响原始数组的情况下创建一个新数组来执行深度复制。这也可以用于对象。

const arr1 = [1, 2, 3, 4, 5]
const arr2 = arr1 // [1, 2, 3, 4, 5]
/*
 This is an example of a shallow copy.
 Where the value of arr1 is copied to arr2
 But now if you apply any method to
 arr2 will affect the arr1 also.  
*/

/*
 This is an example of a deep copy. 
 Here the values of arr1 get copied but they 
 both are disconnected. Meaning if you
 apply any method to arr3 it will not
 affect the arr1.
 */
 const arr3 = [...arr1] // [1, 2, 3, 4, 5]

<Modal {...{ title: "modal heading", animation: false, ...props} />

更加清晰。