jluzh00 2019-06-28
在ES6语法中,...操作符
有两种意义:rest
(剩余语法,rest参数) 和 spread
(展开语法,展开数组/对象),作为函数、数组、对象的扩展运算符。
剩余语法将多个元素收集起来并“凝聚”为单个元素,而展开语法则是将数组/对象展开为其中的各个元素。
(...变量名)
,将一个不定数量的参数表示为一个数组。用于获取函数
实参中的多余参数,组成一个数组,这样就不需要使用arguments对象了。语法
function(a, b, ...theArgs) { // ... }
注意:
函数的length属性不包括rest参数。
(function(a,b,...c){}).length //2
function sumOnlyNumbers() { var args = arguments; var numbers = filterNumbers(); return numbers.reduce((sum, element) => sum + element); function filterNumbers() { return Array.prototype.filter.call(args, element => typeof element === 'number' ); } } sumOnlyNumbers(1, 'Hello', 5, false); // => 6
缺点:
首先我们要将arguments分配给给一个临时新变量args,这样才能在内部函数filterNumbers中可以访问args新变量,因为 filterNumbers()定义了它自己的arguments 会覆盖外部的arguments 。这种做法太冗余了。优化:
使用rest操作符可以灵活解决这个问题,允许在函数中定义一个rest参数 ...args:
function sumOnlyNumbers(...args) { var numbers = filterNumbers(); return numbers.reduce((sum, element) => sum + element); function filterNumbers() { return args.filter(element => typeof element === 'number'); } } sumOnlyNumbers(1, 'Hello', 5, false); // => 6
剩余参数和 arguments 对象的区别
摘自arguments 对象不是一个真实的数组,而剩余参数是真实的 Array实例。所以,
能够在剩余参数上面直接使用所有的数组方法,比如 sort,map,forEach,pop。
而如果想在arguments对象上使用数组方法,你首先得将它转换为真实的数组。
[].slice.call(arguments)
let [first,...rest]=[1,2,3,4,5]; first //1 rest //[2,3,4,5]
// ES5 a = list[0], rest = list.slice(1) // ES6 [a, ...rest] = list
const [first, ...rest] = []; first // undefined rest // []
let { x, ...y } = { x: 1, a: 2, b: 3 }; x // 1 y // { a: 2, b: 3 }
// 浅拷贝 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
上面代码中,变量x是单纯的解构赋值
,所以可以读取对象o继承的属性;变量y和z是扩展运算符的解构赋值
,只能读取对象o自身的属性,所以变量z可以赋值成功,变量y取不到值。
ES6 规定,变量声明语句之中,如果使用解构赋值,扩展运算符后面必须是一个变量名,而不能是一个解构赋值表达式
,所以上面代码引入了中间变量newObj,如果写成下面这样会报错。
let { x, ...{ y, z } } = o; // SyntaxError: ... must be followed by an identifier in declaration contexts
注意:
只能放在参数最后一位
,否则会报错。要求等号右边是一个对象
,如果等号右边是undefined或null,就会报错,因为它们无法转为对象。浅拷贝
,即如果一个键的值是复合类型的值(数组、对象、函数)、那么解构赋值拷贝的是这个值的引用,而不是这个值的副本...运算符
的解构赋值,不能复制继承自原型对象的属性
扩展某个函数的参数,引入其他操作。
function baseFunction({ a, b }) { // ... } function wrapperFunction({ x, y, ...restConfig }) { // 使用 x 和 y 参数进行操作 // 其余参数传给原始函数 return baseFunction(restConfig); }
spread运算则可以看作是rest参数的逆运算。
1.展开数组作为函数参数(...arr)
, 可以将数组转化为逗号分隔的参数序列
console.log(1,...arr) arr1.push(...arr);
注意:
push方法的参数不能是数组
函数应用实例
JavaScript 的函数只能返回一个值,如果需要返回多个值,只能返回数组或对象。扩展运算符提供了解决这个问题的一种变通方法。
var dateFields = readDateFields(database); var d = new Date(...dateFields);
上面代码从数据库取出一行数据,通过扩展运算符,直接将其传入构造函数Date。
2.复制数组
const a2 = a1.concat(); // ES5 const itemsCopy = [...items]; // ES6
注意:
这两种方法都是浅拷贝,使用的时候需要注意。
3.合并数组
// 合并生成一个新的数组,不影响原来的两个数组 arr = [4].concat(list) // ES5 arr = [4, ...list] // ES6
// 扩展arr变量,追加arr2 Array.prototype.push.apply(arr, list); // ES5 arr.push(...list); // ES6
如果扩展运算符后面是一个空数组,则不产生任何效果
[...[], 1] // [1]
4.可以替代apply方法,apply要求将参数合并为数组,作为参数传入
Function.apply(obj,args)方法能接收两个参数
数组没有max方法。Math.max.apply(null,[]);
Math.max.apply(null,[14,3,7]) // ES5写法 Math.max(...[14,3,7]) // ES6写法 // 等同于 Math.max(14, 3, 77);
5.扩展运算符后面还可以放置表达式。
const arr = [ ...(x > 0 ? ['a'] : []), 'b', ];
1.拷贝
let z = { a: 3, b: 4 }; let n = { ...z }; // { a: 3, b: 4 }
这等同于使用Object.assign方法。
let aClone = { ...a }; // 等同于, let aClone = Object.assign({}, a);
上面的例子只是拷贝了对象实例的属性。
2.完整克隆一个对象,拷贝实例属性+对象原型的属性
// 写法一 const clone1 = { __proto__: Object.getPrototypeOf(obj), ...obj }; // 写法二 const clone2 = Object.assign( Object.create(Object.getPrototypeOf(obj)), obj ); // 写法三 const clone3 = Object.create( Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj) )
上面代码中,写法一的__proto__属性在非浏览器的环境不一定部署,因此推荐使用写法二和写法三。
3.合并对象
// 合并 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 });
上面代码中,a对象的x属性和y属性,拷贝到新对象后会被覆盖掉。这用来修改现有对象部分的属性就很方便了
let newVersion = { ...previousVersion, name: 'New Name' // Override the name property };
上面代码中,newVersion对象自定义了name属性,其他属性全部复制自previousVersion对象。
如果把自定义属性放在扩展运算符前面,就变成了设置新对象的默认属性值。let aWithDefaults = { x: 1, y: 2, ...a }; // 等同于 let aWithDefaults = Object.assign({}, { x: 1, y: 2 }, a); // 等同于 let aWithDefaults = Object.assign({ x: 1, y: 2 }, a);
如果扩展运算符后面是一个空对象,则没有任何效果。
如果扩展运算符的参数是null或undefined,这两个值会被忽略,不会报错
。
{...{}, a: 1} // { a: 1 } let emptyObject = { ...null, ...undefined }; // 不报错
4.与数组的扩展运算符一样,对象的扩展运算符后面可以跟表达式。
const obj = { ...(x > 1 ? {a: 1} : {}), b: 2, };
5.对象中取值函数get
问题
// 并不会抛出错误,因为 x 属性只是被定义,但没执行 let aWithXGetter = { ...a, get x() { throw new Error('not throw yet'); } }; // 会抛出错误,因为 x 属性被执行了 let runtimeError = { ...a, ...{ get x() { throw new Error('throw now'); } } };
[...'hello'] // [ "h", "e", "l", "l", "o" ]
Unicode 是有两个字节、四字节之区分。上面的写法,有一个重要的好处,那就是能够正确识别四个字节的 Unicode 字符。
'x\uD83D\uDE80y' //'x