JavaScript数组一篇中介绍了ES6之前的数组方法。本篇介绍一下ES6里新增的数组方法。
- find，findIndex，inclueds
- fill，copyWithin
- keys，values，entries
- 静态方法（from，of）
find，findIndex，inclueds
find用于找元素，返回第一个满足条件的元素，找不到就返回undefined。函数声明：[].find( function(value, index, array) { … }, [thisArg] );。参照MDN
第一个参数是回调函数，它支持3个参数，第1个是遍历的数组内容，第2个是对应索引，第3个是数组自身。第二个参数thisArg可选，可用于以改变回调函数里面的this指针
var count = [1, 5, 10, 15].find(function(value, index, arr) {
return value > 9;
});
console.log(count); //10
findIndex用于找元素，返回第一个满足条件的元素的位置，找不到就返回-1。函数声明：[].findIndex( function(value, index, array) { … }, [thisArg] );，和上面find一样，不赘述。参照MDN
var idx = [1, 5, 10, 15].findIndex(function(value, index, arr) {
return value > 9;
});
console.log(idx); //2
这两个方法都可以发现NaN，弥补了之前indexOf方法的不足。indexOf方法无法识别数组的NaN元素，但findIndex方法可以借助Object.is方法做到：
var idx1 = [NaN].indexOf(NaN);
console.log(idx1); //-1
var idx2 = [NaN].findIndex(y => Object.is(NaN, y));
console.log(idx2); //0
includes用于找元素，找到返回true，找不到返回false。函数声明：[].includes(el, [start]);。参照MDN
第一个参数是查找的元素。第二个参数可选，表示开始查找的位置，不指定的话默认为0，指定为负数，表示倒着数。
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
以前要看数组中是否包含某元素用indexOf：if (arr.indexOf(el) !== -1) { … }。除了感觉有点不自然外，也无法判断是否包含NaN。现在用includes就没这些问题了。
fill，copyWithin
fill用于填充当前数组，返回填充后的数组。函数声明：[].fill(value, [start, [end]]);。参照MDN
第一个参数是填充的元素，后两个参数可选，start是起始填充位置，不指定的话默认为0。end是填充到哪个位置之前结束，不指定的话默认到数组尾。位置可以指定负数，表示倒着数。
var arr = [1, 2, 3];
console.log(arr.fill(4)); // [4, 4, 4]
console.log(arr.fill(4, 1)); // [1, 4, 4]
console.log(arr.fill(4, 1, 2)); // [1, 4, 3]
console.log(arr.fill(4, -3, -2)); // [4, 2, 3]
用上面第一行例子，即单个参数，来初始化数组非常方便，数组中原有元素将全部被抹去。
copyWithin和fill很像，它用于将数组指定位置的元素复制到其他位置（会覆盖原来该位置的元素），最后返回修改后的数组。函数声明：[].copyWithin(target, [start, [end]]);。参照MDN
第一个参数和fill有区别，是从该位置开始替换元素。后两个参数参照fill，不赘述
var arr = ['a', 'b', 'c', 'd', 'e', 'f'];
console.log(arr.copyWithin(0, 3)); // ['d', 'e', 'f', 'd', 'e', 'f']
表示将从index为3开始直到数组结束的成员（即def）读取出来，替换从0号位开始的元素（即覆盖了abc）。
再看一个负数的例子：
var arr1 = [1, 2, 3, 4, 5];
console.log(arr1.copyWithin(-2, -3, -1)); // [1, 2, 3, 3, 4]
从倒数3位开始直到倒数1位（即34）读取出来，替换倒数2位（即覆盖了45）
keys，values，entries
这3个方法都用于遍历数组。都返回一个遍历器对象，可以用for…of循环进行遍历。区别是keys是对key的遍历，values是value的遍历，entries是对key-value的遍历。
函数声明都非常简单，一个参数都没有，分别是：[].keys();，[].values();，[].entries();。参照MDN
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 (let [index, elem] of ['a', 'b'].entries()) {
console.log(index, elem);
}
// 0 "a"
// 1 "b"
因为返回的是遍历器对象，因此除了for…of循环外，也可以手动调用遍历器对象的next方法来遍历：
var arr = ['a', 'b', 'c'];
var eArr = arr.entries();
console.log(eArr.next().value); // [0, 'a']
console.log(eArr.next().value); // [1, 'b']
console.log(eArr.next().value); // [2, 'c']
静态方法（from，of）
JavaScript数组一篇中介绍了ES6之前的数组方法，包括本篇上面所有Array的方法的函数声明都用了“[].方法名”的形式，等价于“Array.prototype.方法”，表示它们都是Array的实例方法。
但form和of的函数声明用了“Array.方法名”的形式，表示它们是Array的静态方法。（关于JS静态可以参照这里）
from用于将类数组对象转为真正的数组。函数声明：Array.from(arrayLike, [mapFn, [thisArg]]);。参照MDN
第一个参数自然就是类数组对象。第二个参数作用类似于map，还可以为map指定this。有关类数组对象和map方法请参照JavaScript数组，不赘述。
现在用ES6的from方法来重写JavaScript数组一篇中的类数组对象中的例子：
处理arguments对象：
//ES5处理arguments对象：
var args = [].slice.call(arguments);
//ES6用from
var args = Array.from(arguments);
处理HTMLCollection对象：
//ES5用forEach遍历页面所有div，输入className
var divs = document.getElementsByTagName("div");
Array.prototype.forEach.call(divs, function(div) {
console.log("该div类名是：" + (div.className || "空"));
});
// ES6用from
Array.from(divs).forEach(function (div) {
console.log("该div类名是：" + (div.className || "空"));
});
处理字面量对象：
//ES5
var arrayLike = { 0: "a", 1: "b", 2: "c", length: 3 };
var result = Array.prototype.map.call(arrayLike, function(s) {
return s.toUpperCase();
});
console.log(result); //["A", "B", "C"]
//ES6
var result = Array.from(arrayLike, s => s.toUpperCase());
console.log(result); //["A", "B", "C"]
上面from用了第二个参数，该语句等价于Array.from(arrayLike).map(s => s.toUpperCase());
处理字符串：
//ES5
var result = Array.prototype.map.call("abc", function(s) {
return s.toUpperCase();
});
console.log(result); //["A", "B", "C"]
//ES6
var result = Array.from("abc", s => s.toUpperCase());
console.log(result); //["A", "B", "C"]
of作用和from类似，用于将一组值，转换为数组。函数声明：Array.of(el0, [el1, … , elN]);。参照MDN
和from一样， 同样是Array的静态方法，你无法用数组对象调用of方法。
console.log(Array.of(1,2,3)); // [1, 2, 3]
你可能会很疑惑，直接var arr = new Array(1,2,3);不就行了，要of方法有什么用？如果只有1个参数就有区别了：
//只有1个参数的普通构造函数
var arr1 = Array(3);
console.log(arr1); // [, , ,]
//ES6用of就和上面有区别了
var arr2 = Array.of(3);
console.log(arr2); // [3]
可以看出用of的话，可以完全替代构造函数，避免了单个参数导致的非常微妙的区别。它总是能返回一个数组，如果没有参数，就返回空数组[]
