Quelle est la fonction des trois points dans es6 ?

Les trois points de

es6 ne sont pas des fonctions, mais un opérateur. Les trois points "..." font référence à "l'opérateur d'expansion", qui peut développer l'objet itérable en ses éléments séparés ; l'objet dit itérable est tout objet qui peut être parcouru à l'aide d'une boucle for of, comme un tableau ; , String, Map, Set, nœud DOM, etc.

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

Opérateur Expand... a été introduit dans ES6, qui développe un objet itérable en ses éléments individuels. L'objet dit itérable est tout objet qui peut être parcouru à l'aide d'une boucle for of, tel que : array (méthode courante de array). ), String, Map (comprendre Map), Set (comment utiliser Set ?), nœud DOM, etc.

Opérateur de propagation de tableau

L'opérateur de propagation (spread) est composé de trois points (...). C'est comme l'opération inverse du paramètre rest, convertissant un tableau en une séquence de paramètres séparés par des virgules. L'opérateur spread peut être utilisé conjointement avec les paramètres de fonction normaux, et une expression peut également être placée après lui, mais s'il est suivi d'un tableau vide, cela n'aura aucun effet. ...）。它好比 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列。扩展运算符与正常的函数参数可以结合使用，后面也可以放置表达式，但如果后面是一个空数组，则不产生任何效果。

let arr = [];
arr.push(...[1,2,3,4,5]);
console.log(arr); //[1,2,3,4,5]
console.log(1, ...[2, 3, 4], 5) //1 2 3 4 5
console.log(...(1 > 0 ? ['a'] : [])); //a
console.log([...[], 1]); //[1]

意义

替代函数的apply方法

由于扩展运算符可以展开数组，所以不再需要apply方法，将数组转为函数的参数了。

// ES5 的写法
Math.max.apply(null, [14, 3, 77])
// ES6 的写法
Math.max(...[14, 3, 77])

应用

• 复制数组

  // ES5 的写法
  const a1 = [1, 2];
  const a2 = a1.concat();
  // ES6 的写法
  const a1 = [1, 2];
  const a2 = [...a1];
  //或
  const [...a2] = a1;

• 合并数组

  // ES5 的写法
  [1, 2].concat(more);
  arr1.concat(arr2, arr3);
  // ES6 的写法
  [1, 2, ...more];
  [...arr1, ...arr2, ...arr3]

• 与解构赋值结合

  // ES5 的写法
  a = list[0], rest = list.slice(1)
  // ES6 的写法
  [a, ...rest] = list

  注意：如果将扩展运算符用于数组赋值，只能放在参数的最后一位，否则会报错。

• 转换字符串

  扩展运算符还可以将字符串转为真正的数组，并且能够正确识别四个字节的 Unicode 字符。

  'x\uD83D\uDE80y'.length // 4
  [...'x\uD83D\uDE80y'].length // 3
  
  let str = 'x\uD83D\uDE80y';
  str.split('').reverse().join('') // 'y\uDE80\uD83Dx'
  [...str].reverse().join('')      // 'y\uD83D\uDE80x'

• 实现Iterator接口的对象

  任何 Iterator 接口的对象（参阅 Iterator 一章），都可以用扩展运算符转为真正的数组。

• Map和Set结构、Generator函数

  • 扩展运算符内部调用的是数据结构的 Iterator 接口，因此只要具有 Iterator 接口的对象，都可以使用扩展运算符，比如 Map 结构。

  let map = new Map([
   [1, 'one'],
   [2, 'two'],
   [3, 'three'],
  ]);
  
  let arr = [...map.keys()]; // [1, 2, 3]

     
  • Generator 函数运行后，返回一个遍历器对象，因此也可以使用扩展运算符。

  const go = function*(){
   yield 1;
   yield 2;
   yield 3;
  };
  
  [...go()] // [1, 2, 3]

     
  • 如果对没有 Iterator 接口的对象，使用扩展运算符，将会报错。

对象的扩展运算符

概念

对象的解构赋值用于从一个对象取值，相当于将目标对象自身的所有可遍历的（enumerable）、但尚未被读取的属性，分配到指定的对象上面。所有的键和它们的值，都会拷贝到新对象上面。

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

注意：

• 由于解构赋值要求等号右边是一个对象，所以如果等号右边是undefined或null，就会报错，因为它们无法转为对象。

• 解构赋值必须是最后一个参数，否则会报错。

• 解构赋值的拷贝是浅拷贝，即如果一个键的值是复合类型的值（数组、对象、函数）、那么解构赋值拷贝的是这个值的引用，而不是这个值的副本。

  let obj = { a: { b: 1 } };
  let { ...x } = obj;
  obj.a.b = 2;
  x.a.b // 2

• 扩展运算符的解构赋值，不能复制继承自原型对象的属性。

  let o1 = { a: 1 };
  let o2 = { b: 2 };
  o2.__proto__ = o1;
  let { ...o3 } = o2;
  o3 // { b: 2 }
  o3.a // undefined
  
  
  const o = Object.create({ x: 1, y: 2 });
  o.z = 3;
  
  let { x, ...newObj } = o;
  let { y, z } = newObj;
  x // 1
  y // undefined
  z // 3
  
  let { x, ...{ y, z } } = o;
  // SyntaxError: ... must be followed by an identifier in declaration contexts

应用

• 扩展某个函数的参数，引入其他操作。

function baseFunction({ a, b }) {
// ...
}
function wrapperFunction({ x, y, ...restConfig }) {
// 使用 x 和 y 参数进行操作
// 其余参数传给原始函数
return baseFunction(restConfig);
}

• 取出参数对象的所有可遍历属性，拷贝到当前对象之中。

let z = { a: 3, b: 4 };
let n = { ...z };
n // { a: 3, b: 4 }

let aClone = { ...a };
// 等同于
let aClone = Object.assign({}, a);

//上面的例子只是拷贝了对象实例的属性，如果想完整克隆一个对象，还拷贝对象原型的属性，可以采用下面的写法。
// 写法一
const clone1 = Object.assign(
Object.create(Object.getPrototypeOf(obj)),
obj
);
// 写法二
const clone2 = Object.create(
Object.getPrototypeOf(obj),
Object.getOwnPropertyDescriptors(obj)
)

• 合并两个对象。

  let ab = { ...a, ...b };
  // 等同于
  let ab = Object.assign({}, a, b);
  
  
  //如果用户自定义的属性，放在扩展运算符后面，则扩展运算符内部的同名属性会被覆盖掉。
  let aWithOverrides = { ...a, x: 1, y: 2 };
  // 等同于
  let aWithOverrides = { ...a, ...{ x: 1, y: 2 } };
  // 等同于
  let x = 1, y = 2, aWithOverrides = { ...a, x, y };
  // 等同于
  let aWithOverrides = Object.assign({}, a, { x: 1, y: 2 });

• 修改现有对象部分的属性。

  let newVersion = {
  ...previousVersion,
  name: 'New Name' // Override the name property
  };

其他

• 如果把自定义属性放在扩展运算符前面，就变成了设置新对象的默认属性值。
• 与数组的扩展运算符一样，对象的扩展运算符后面可以跟表达式。
• 如果扩展运算符后面是一个空对象，则没有任何效果。
• 如果扩展运算符的参数是null或undefined，这两个值会被忽略，不会报错。

• 扩展运算符的参数对象之中，如果有取值函数getrrreee

Signification

Remplacer la méthode apply de la fonctionPuisque l'opérateur spread peut étendre le tableau, la méthode apply n'est plus nécessaire pour convertir le tableau en paramètre de la fonction . rrreee

🎜App 🎜🎜

• 🎜Copier le tableau🎜rrreee🎜
• 🎜Fusionner les tableaux🎜rrreee🎜
• 🎜Combiné avec l'affectation de déstructuration🎜rrreee🎜🎜Remarque : Si l'opérateur spread est utilisé pour l'affectation du tableau, il ne peut être placé qu'au dernier bit du paramètre, sinon une erreur sera signalée . 🎜🎜🎜
• 🎜Convertir des chaînes🎜🎜L'opérateur de propagation peut également convertir des chaînes en tableaux réels et identifier correctement les caractères Unicode de quatre octets. 🎜rrreee🎜
• 🎜Objets qui implémentent l'interface Iterator🎜🎜Tout objet de l'interface Iterator (voir le chapitre Iterator) peut être converti en un véritable tableau à l'aide de l'opérateur spread. 🎜🎜
• 🎜Map and Set structure, Generator function🎜
  • L'opérateur spread appelle en interne l'interface Iterator de la structure de données, donc tant que l'objet a l'interface Iterator, l'opérateur spread peut être utilisé , comme la structure de la carte. 🎜🎜rrreee
    • Une fois la fonction Générateur exécutée, elle renvoie un objet traverseur, donc l'opérateur spread peut également être utilisé. 🎜🎜rrreee
      • 🎜Si vous utilisez l'opérateur spread sur un objet sans interface Iterator, une erreur sera signalée. 🎜🎜🎜🎜🎜🎜🎜L'opérateur de propagation d'un objet🎜🎜🎜🎜Concept🎜🎜🎜L'affectation déstructurante d'un objet est utilisée pour obtenir une valeur d'un objet, qui est équivalente à tous les traversables (énumérables) de la cible objet lui-même, mais ne l'a pas encore été. Les attributs de lecture sont attribués à l'objet spécifié. Toutes les clés et leurs valeurs seront copiées dans le nouvel objet. 🎜rrreee🎜🎜Remarque : 🎜🎜
        • 🎜Puisque l'affectation de déstructuration nécessite que le côté droit du signe égal soit un objet, donc si le côté droit du signe égal le signe égal est undefined code> ou <code>null, une erreur sera signalée car ils ne peuvent pas être convertis en objets. 🎜🎜
        • 🎜L'affectation de déstructuration doit être le dernier paramètre, sinon une erreur sera signalée. 🎜🎜
        • 🎜La copie de l'affectation de déstructuration est une copie superficielle, c'est-à-dire que si la valeur d'une clé est une valeur de type composite (tableau, objet, fonction), alors l'affectation de déstructuration copie une référence à la valeur, pas une copie de la valeur. 🎜rrreee🎜
        • 🎜L'affectation de déstructuration de l'opérateur spread ne peut pas copier les propriétés héritées de l'objet prototype. 🎜rrreee🎜🎜🎜🎜Application🎜🎜
          • 🎜Développez une fonction Paramètres, introduire d'autres opérations. 🎜🎜🎜rrreee
            • 🎜Obtenez tous les attributs traversables de l'objet paramètre et copiez-les dans l'objet actuel. 🎜🎜🎜rrreee
              • 🎜Fusionner deux objets. 🎜rrreee🎜
              • 🎜Modifiez les propriétés d'une partie d'objet existante. 🎜rrreee🎜🎜🎜Autres🎜
                • Si vous placez l'attribut personnalisé devant l'opérateur de propagation, il devient la valeur d'attribut par défaut du nouvel objet. 🎜
                • Comme l'opérateur spread pour les tableaux, l'opérateur spread pour les objets peut être suivi d'une expression. 🎜
                • Si l'opérateur spread est suivi d'un objet vide, cela n'a aucun effet. 🎜
                • Si le paramètre de l'opérateur spread est null ou undefined, ces deux valeurs seront ignorées et aucune erreur ne sera signalée. 🎜
                • 🎜S'il y a une fonction de valeur get dans l'objet paramètre de l'opérateur d'expansion, cette fonction sera exécutée. 🎜🎜🎜🎜【Recommandations associées : 🎜Tutoriel vidéo javascript🎜, 🎜Vidéo de programmation🎜】🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!