数组的扩展

8.1 扩展运算符

8.1.1 含义

扩展运算符（spread）是三个点（...),它如同rest参数的逆运算，将一个数组转为用逗号分隔的参数序列。

console.log(...[1,2,3])
// 1 2 3 

console.log(1,...[2,3,4],5)
// 1 2 3 4 5

[...document.querySelectorAll('div')]
// [<div>,<div>,<div>]
该运算符主要用于函数调用
function push(array,...items){
	array.push(...items);
}
function add(x,y) {
	return x + y;
	}
var number = [4,38];
add(...number) //42
	上面的代码中，array.push(...items)和add(...numbers)这两行都是函数的调用，他们都使用了扩展运算符，该运算符可以将一个数组变为参数序列。
	扩展运算符与正常的函数参数可以结合使用，非常灵活。
	
function f(v,w,x,y,z){}
var args = [0,1];
f(-1,...args,2,...[3]);
**扩展运算符后面还可以放置表达式**
	const arr = [...(x > 0?['a']:[]),'b',]
	
	如果扩展运算符后面是一个空数组，则不产生任何效果。
[...[],1]
// [1]

8.1.2 替代数组的apply方法

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

// ES5的写法
	function f(x,y,z) {
		//...
	}
	var args = [0,1,2];
	f.apply(null,args);
	// ES6的写法
	function f(x,y,z){
		//...
	}
	var args = [0,1,2];
	f(...args);
	下面是扩展运算符取代apply方法的一个实际例子：
	应用Math.max f方法简化求出一个数组中的最大元素。
	//ES5的写法
	Math.max.apply(null,[14,3,77])
	//ES6的写法
	Math.max(...[12,3,77])
	//等同于
	Math.max(12,3,77);
	上面的代码中，由于JavaScript不提供求数组最大元素的函数，所以只能嵌套Math.max函数将数组转为一个参数序列，然后求最大值，有了扩展运算符以后就可以直接使用Math.max了
	

8.1.3 扩展运算符的应用

合并数组

	扩展运算符提供了数组合并的新写法。
	//ES5
	[1,2].concat(more)
	//ES6
	[1,2,...more]
	
	var arr1 = ['a','b'];
	var arr2 = ['c'];
	var arr3 = ['d','e'];
	
	//ES5的合并数组
	arr1.concat(arr2,arr3);
	//['a','b','c','d','e'];
	
	//ES6的合并数组
	[...arr1,...arr2,...arr3);
	//['a','b','c','d','e'];

与解构赋值结合

	扩展运算符可以与解构赋值结合起来，用于生成数组。
	//ES5
	a = list[0],rest = list.slice(1)
	//ES6
	[1,...rest] = list
	下面是另外一些列子
	const [first,...rest] = [1,2,3,4,5];
	first //1
	rest // [2,3,4,5]

	const [first,...rest] = [];
	first //undefined
	rest //[]
	
	const [first,...rest] = ["foo"];
	first //"foo"
	rest //[]
	如果将扩展运算符用于数组赋值，则只能将放在参数的最后一位，否者会报错
	const [...butLast,last] = [1,2,3,4,5];
	//报错

	const [fitst,...middle,last] = [1,2,3,4,5];
	//报错

函数的返回值
JavaScript的函数只能返回一个值，如果需要返回多个值，只能返回数组或对象，扩展运算符提供了解决这个问题的一种变通方法

	var dateFields = readDateFields(database);
	var d = new Date(...dateFields );
	上面的代码从数据库中取出一行数据，通过扩展运算符，直接将其传入构造函数Date。

## 字符串
扩展运算符还可以将字符串转为真正的数组。
[…‘hello’]
//[‘h’,‘e’,‘l’,‘l’,‘o’]

8.2 Array.form()

Array.from方法用于将两类对象转为真正的数组，类似数组对象和可遍历（iterable）对象（包括ES6新增的数据结构Set和Map）。

下面是一个类似数组的对象，Array.from将它转为真正的数组。

	let arratLike = {
		'0':'a',
		'1':'b',
		'2':'c',
		lenght：3
	};
//ES5的写法
	var arr1 = [].slice.call(arrayLike);//['a','b','c']

//ES6的写法
	let arr2 = Array.from(arrayLike); //['a','b','c']
实际应用中，常见的类似数组的对象是DOM操作返回的NodeList集合，以及函数内部的argument对象。Array.from都可以将他们转为真正的数组。
	//NodeList对象
	let ps = document.querySelectorAll('p');
	Array.from(ps).forEach(function (p) {
		console.log(p);
	});
	
	//argument对象
	function foo() {
		var args = Array.from(arguments);
		//...
	}
	上面的代码中，querySelectorAll 方法返回的是一个类似数组的对象，只有将这个对象专为真正的数组，才能使用forEach方法。
	只要是部署了Iterator接口的数据结构，Array.from都能将其转为数组。
	Array.from('hello')
	// ['h','e','l','l','o']

	let namesSet = new Set(['a','b'])
	Array.from(namesSet)//['a','b']
	上面的代码中，字符串和Set结构都具有Iterator接口，因此可以被Array.from转为真正的数组。
	如果参数是一个真正的数组，Array.from会返回一个一模一样的新数组。

	Array.from([1,2,3])
	//[1,2,3]
	值得提醒的是，扩展运算符（...)也可以将某些数据结构转为数组。
	//arguments对象
	function foo() {
		var args = [...arguments];
	}

	//NodeList对象
	[...document.querySelectorAll('div')]
	扩展运算符背后调用的是遍历器接口（Symbol.iterator),如果一个对象没有部署该接口，就无法转换。Array.form方法还支持类似数组的对象。所谓类似数组的对象，本质特征只有一点，即必须有length属性。因此，任何length属性的对象，都可以通过Array.from方法转为数组，而这种情况扩展运算符无法转换。
	Array.from({ length:3});
	// [ undefined.undefinde,undefined]

	上面的代码中，Array.from返回了一个具有3个成员的数组，每个位置的值都是undefined，扩展运算符转换不了这个对象。
	对于还没有部署该方法的浏览器，可以用Array.prototype.slice方法替代。
	
	const toArray = (() =>
		Array.from ?Arrat.from : obj =>[].slice.call(obj)
		}();
	Array.from还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组。

	Array.from(arraytLike,x => x*X);
	//等同于
	Array.from(arrayLike).map(x => x * x);
	Array.from([1,2,3],(x) => x * x);
	//[1,4,9]
	下面的例子是取出一组DOM节点的文本内容。
	let spans = document.querSelectorAll('span.name');

	//map()
	let names1 = Arrat.prototype.map.call(spans,s => s.textContent);
	
	//Array.from()
	let names2 = Array(spans.s => s.textContent);
	下面的例子将数组中布尔值为false的成员转为0.
	Array.from([1, ,2, ,3],(n) = >n || 0)
	//[1,0,2,0,3]
	另一个例子是返回各种数据类型
	function typeOf() {
		return Array.from(arguments, value => typeof value)
	}
	typesOf(null,[],NaN)
	//['object','object','number']
	如果map函数里面用到了this关键字，还可以传入Array.from第三个参数，用来绑定this。
	Array.from()可以将各种值转为真正的数组，并且提供map功能。这实际上意味着只要有一个原始的数据结构，就可以先对它的值进行处理，然后转成规范的数组结构，进而可以使用数量众多的数组方法，
	Array.from({ length:2},()=>'jack')
	//['jack','jack']
	上面的代码中，Array.from的第一个参数指定了第二个参数运行的次数。这种特性可以让该方法的用法变得非常灵活。
	Array.from()的另一个应用是，将字符串转为数组，然后返回字符串的长度。因为它能正确处理各种Unicode字符，可以避免JavaScript将大于\uFFFF的Unicode字符算作2个字符的bug。
	funciton countSymbls(string){
		return Array.from(string).length;
	}

8.3 Array.of()

Array.off方法用于将一组值转换为数组

	Array.of(3,11,8) //[3,11,8]
	Array.of(3) //[3]
	Array.of(3).length //1
	
	这个方法的主要目的的是弥补数组构造函数Array（）的不足。因为参数个数的不同会导致Array()的行为有差异。
	Array() //[]
	Array(3) //[, , ,]
	Array(3,11,8) //[3,11,8]
	
	上面的代码中，Array方法没有参数，有1个参数或有3个参数时，返回结果都不一样。只有当参数个数不少于2个时，Array()才会返回有参数组成的新数组。参数个数只有1个时，实际上是指定数组的长度。
	Array.of基本上可以用来替代Array（）或new Array(),并且不存在由于参数不同而导致的重载。他的行为非常统一。
	
	Array.of() //[]
	Array.of(undefined) //[undefined]
	Array.of(1) //[1]
	Array.of(1,2) //[1,2]
	
	Array.of总是返回参数值组成的数组，如果没有参数，就返回一个空数组。
	Array.of方法可以用下面代码模拟实现。
	
	function ArrayOd(){
		return [].slice.call(arguments);
	}

8.4 数组实例的copyWithin()

数组实例的copyWithin（）方法会在当前数组内部将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，**使用这个方法会修改当前数组。**

	Array.prototype.copyWithin(target,start = 0,end = this.length)

它接受3个参数

• target(必选)：从该位置开始替换数据。
• start(可选):从该位置开始读取数据，默认为0，如果为负值，表示倒数。
• end(可选）：到该位置前停止读取数据，默认等于数组长度，如果为负值，表示倒数。
  这3个参数都应该是数组，如果不是，会自动转为数值。

	[1,2,3,4,5].copyWithin(0,3)
	//[4,5,3,4,5]
	上面的代码表示，将从3号位置直到数值结束的成员（4和5)复制到从0号位置开始的位置，结果覆盖了原来的1和2.
	//将3号位复制到0号位
	[1,2,3,4,5].copuWithin(0,3,4)
	//[4,2,3,4,5]

8.5 数组实例的find()和findIndex()

数组实例的find方法用于找出第一个符合条件的数组成员。他的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true 的成员，然后返回该成员。如果没有符合条件的成员，则返回undeifined。

	[1,3,-5,10].find((n) => n < 0)
	// -5
	上面的代码可以找出数组中第一个小于0的成员，
	[1,2,10,15].find(function(value,index,arr) {
		return value >9;
	}) //10
	上面的代码中，find方法的回调函数可以接受3个参数，一依次为**当前的值**，**当前的位置**，**和原数组**。

数组实例的findIndex方法的用法于find方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1

	[1,5,10,15].findIndex(funciton(value,index,arr) {
		return value >9;
	})//2
	这两个方法都可以接受第二个参数，用来绑定回调函数的this对象。
	另外，这两个方法都可以发现NaN，弥补了数组的IndexOf方法的不足
	[NaN[.indexOf(NaN)
	// -1

	[NaN].findIndex(y => Object.is(NaN,y);
	// 0
	上面的代码中，indexOf方法无法识别数组的NaN成员，但是findIndex方法可以借助Object.is方法做到。

8.6 数组实例的fill()

	fill方法使用给定值填充一个数组
	['a','b','c'].fill(7)
	//[7,7,7]

	new Array(3).fill(7)
	//[7,7,7]
	上面的代码表明，fill方法用于空数组的初始化时非常方便。数组中已有的元素会被全部抹去。
	fill方法还可以接受第二个和第三个参数，用于指定填充的起始位置和结束位置。
	['a','b','c'].fill(7,1,2)
	//['a',7,'c']
	上面的代码表示，fill方法从1号位开始向原数组填充7，到2号位之前结束。

8.7 数组实例的entries(),keys()和values()

ES6提供了3个新方法-----entries(),keys()和values() -----用于遍历数组。他们都返回一个遍历器对象，可用for…of循环遍历，唯一的区别在于，keys()是对键名的遍历，values()是对键值的遍历，entries()是对键值对的遍历

	for (let index of ['a','b'].keys()) {
		console.log(index);
	}
	// 0
	// 1
	for (let elem of ['a','b'].values()) {
		console.log(elem);
	}
	//'a'
	//'b'
	如果不使用for...of循环，可以手动调用遍历器对象的next方法进行遍历。
	let letter = ['a','b','c']
	let entries = letter.entries();
	console.log(entries.next().value);//[0,'a']
	console.log(entries.next().value);//[1,'b']
	console.log(entries.next().value);//[2,'c']
	

8.8 数组实例的includes()
Array.prototype.includes方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。ES2016引入了该方法。

	[1,2,3].includes(2) //true
	[1,2,3,NaN].includes(NaN) //true
	[1,2,3].includes(4) //false
	该方法的第二个参数表示搜索的起始位置，默认为0，如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为-4，但数组长度为3），则会重置为从0开始。
	[1,2,3].includes(3,3);//false
	[1,2,3].includes(3,-1);//true
	没有该方法之前，我们通常使用数组的indexOf方法检查是否包含某个值