python求函数零点_ES6 ...操作符

在ES6语法中，...操作符有两种意义：rest(剩余语法，rest参数) 和 spread(展开语法，展开数组/对象)，作为函数、数组、对象的扩展运算符。

从某种意义上说，剩余语法与展开语法是相反的：

剩余语法将多个元素收集起来并“凝聚”为单个元素，而展开语法则是将数组/对象展开为其中的各个元素。

剩余语法

rest参数

形式为(...变量名)，将一个不定数量的参数表示为一个数组。用于获取函数实参中的多余参数，组成一个数组，这样就不需要使用arguments对象了。

语法

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

// ...

}

注意：

rest参数之后不能再有其他参数(只能是最后一个参数)否则会报错。

函数的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 对象包含了传给函数的所有实参。

arguments 对象不是一个真实的数组,而剩余参数是真实的 Array实例。

所以，能够在剩余参数上面直接使用所有的数组方法，比如 sort，map，forEach，pop。

而如果想在arguments对象上使用数组方法,你首先得将它转换为真实的数组。

[].slice.call(arguments)

arguments 对象对象还有一些附加的属性 (比如callee属性)。

解构赋值

数组

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，就会报错，因为它们无法转为对象。

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

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

变量声明语句之中，如果使用解构赋值，扩展运算符后面必须是一个变量名，而不能是一个解构赋值表达式

rest参数&解构赋值

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

function baseFunction({ a, b }) {

// ...

}

function wrapperFunction({ x, y, ...restConfig }) {

// 使用 x 和 y 参数进行操作

// 其余参数传给原始函数

return baseFunction(restConfig);

}

展开语法

spread运算则可以看作是rest参数的逆运算。

数组

展开数组作为参数序列、复制数组、合并数组、代替apply、...+表达式

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)方法能接收两个参数

obj：这个对象将代替Function类里this对象

args：这个是数组，它将作为参数传给Function(args-->arguments)

数组没有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',

];

对象

复制对象、完整克隆、合并对象、...+表达式、取值函数get

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问题

扩展运算符的参数对象之中，如果有取值函数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🚀y'

'x\uD83D\uDE80y'.length // 4

[...'x\uD83D\uDE80y'].length // 3

上面代码的第一种写法，JavaScript 会将四个字节的 Unicode 字符，识别为 2 个字符，采用扩展运算符就没有这个问题。因此，正确返回字符串长度的函数，可以像下面这样写。

function length(str) {

return [...str].length;

}

length('x\uD83D\uDE80y') // 3

凡是涉及到操作四个字节的 Unicode 字符的函数，都有这个问题。因此，最好都用扩展运算符改写。

let str = 'x\uD83D\uDE80y';

str.split('').reverse().join('') // 'y\uDE80\uD83Dx'

[...str].reverse().join('') // 'y\uD83D\uDE80x'

上面代码中，如果不用扩展运算符，字符串的reverse操作就不正确。reverse，颠倒数组中元素的顺序，会改变原来的数组，而不会创建新的数组。

实现了 Iterator 接口的对象

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

let nodeList = document.querySelectorAll('div'); //nodeList 类数组对象

let array = [...nodeList];

这时，...运算符可以将其转为真正的数组，原因就在于NodeList对象实现了 Iterator 。

对于那些没有部署 Iterator 接口的类似数组的对象，...运算符就无法将其转为真正的数组。

let arrayLike = {

'0': 'a',

'1': 'b',

'2': 'c',

length: 3

};

// TypeError: Cannot spread non-iterable object.

let arr = [...arrayLike];

上面代码中，arrayLike是一个类似数组的对象，但是没有部署 Iterator 接口，扩展运算符就会报错。这时，可以改为使用Array.from方法将arrayLike转为真正的数组。

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]

上面代码中，变量go是一个 Generator 函数，执行后返回的是一个遍历器对象，对这个遍历器对象执行扩展运算符，就会将内部遍历得到的值，转为一个数组。

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

const obj = {a: 1, b: 2};

let arr = [...obj]; // TypeError: Cannot spread non-iterable object