es6基础系列五--数组的拓展

Array.from()

用于将两类对象转为真正的数组，类似数组对象和可遍历对象(包括数据结构Set和Map)转化为数组

格式：Array.from(arrayLike[, mapFn[, thisArg]])

// 字符串
Array.from('foo'); // ["f", "o", "o"]

// Set结构，类似数组，是个集合，具有add,has,delete,clear等方法，后面详细说
var s = new Set(['foo', window]);
Array.from(s); // ["foo", window]

// Map结构，类似对象，具有size,get,set,has,delete,clear等方法，后面详细说
var m = new Map([[1, 2], [2, 4], [4, 8]]);
Array.from(m); // [[1, 2], [2, 4], [4, 8]]

// Array-like object (arguments)
function f() {
  return Array.from(arguments);
}
f(1, 2, 3); // [1, 2, 3]

// 箭头函数操纵参数，箭头函数下一节详细说
Array.from([1, 2, 3], x => x + x);
// [2, 4, 6]
// 等同于
Array.from([1, 2, 3]).map(x => x + x)
// 等同于
Array.from([1,2,3]).map(function(x){
	return x+x;
})

Array.from({length: 5}, (v, i) => i);
// [0, 1, 2, 3, 4]
// 等同于
Array.from({length: 5}).map((v, i) => i)

Array.of()

用于将一组值，转换为数组

格式：Array.of(element0[, element1[, ...[, elementN]]])

Array.of(1);         // [1]
Array.of(1, 2, 3);   // [1, 2, 3]
Array.of(undefined); // [undefined]

这个方法的主要目的，是弥补数组构造函数Array()的不足。因为参数个数的不同，会导致Array()的行为有差异。

Array() // []
Array(3) // [undefined, undefined, undefined]
Array(3, 4, 5) // [3, 4, 5]

如果考虑浏览器不支持Arrray.of方法，可以用下面代码实现

if (!Array.of) {
  Array.of = function() {
    return Array.prototype.slice.call(arguments);
  };
}

find()和findIndex()

用于找出第一个符合条件的数组元素。

格式：arr.find(callback[, thisArg])

callback是回调函数，找到返回值为ture则返回该元素，否则返回undefined;

另外，findIndex()和find()类似，只是返回第一个符合条件的数组元素位置，都不符合则返回-1

[1, 5, 10, 15].find(function(value, index, arr) {
    return value > 9;
}) // 10
[1, 5, 10, 15].findIndex(function(value, index, arr) {
    return value > 9;
}, window) // 2

[2, 3, NaN, 5].find(function(value, index, arr){
	return Object.is(NaN, value);
}) // NaN
[2, 3, NaN, 5].findIndex(function(value, index, arr){
	return Object.is(NaN, value);
}) // 2

fill()

用于给定值填充数组

格式：arr.fill(value, start, end) start和end表示开始位置、结束位置属于可选项

可用于数组的初始化，注意：数组中已有的元素，会被替换

[1, 2, 3].fill(4);               // [4, 4, 4]
[1, 2, 3].fill(4, 1);            // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
Array(3).fill(4);                // [4, 4, 4]

entries()，keys()和values()

格式：arr.entries(), arr.keys(), arr.values()

这三个方法都是用于遍历数组，其中，entries()是对键值对的遍历，keys()是对键名的遍历、values()是对键值的遍历

for(let i of ["a", "b"].keys()){
	console.log(i);
}
// 0
// 1

for(let el of ["a", "b"].values()){
	console.log(el);
}
// 浏览器暂不支持，理论上会输出a, b的

for (let [index, elem] of ['a', 'b'].entries()) {
  console.log(index, elem);
}
// 0 "a"
// 1 "b"

map()

用于提供该数组每个元素调用一次回调函数返回结果组成的新数组

格式：var new_array = arr.map(callback[, thisArg])

[1, 4, 9].map(Math.sqrt); // [1, 2, 3]
[1, 4, 9].map(function(num){
	return num*2
}) // [2, 8, 18]
// es6中的 =>
[1, 4, 9].map(num => num*2); // [2, 8, 18]

// 数组里包含格式化对象
var kvArray = [{key: 1, value: 10},
               {key: 2, value: 20},
               {key: 3, value: 30}];
var newArr = kvArray.map(function(obj){
	var o = {};
	o.key = obj.key;
	o.value = obj.value*2
	return o;
});
console.log(JSON.stringify(newArr)); // [{"key":1,"value":20},{"key":2,"value":40},{"key":3,"value":60}]

filter()

用于提供该数组每个元素通过回调函数过滤返回结果组成的新数组

格式：var newArray = arr.filter(callback[, thisArg])

注意：跟map()方法的区别，是通过过滤，结果为ture时的元素，不通过回调函数过滤的则忽略

[1, 4, 9].filter(num => num>2); // [4, 9]
[1, 4, 9].map(num => num>2); // [false, true, true]

reduce()

可以称之为迭代器或者累加器，用于把数组中单个元素调用一次回调元素返回结果迭代后再去调用下一个元素，最终返回一个值

格式：arr.reduce(callback, [initialValue])；callback的参数包括accumulator(回调返回的值或初始值)、currentValue(当前元素值)、currentIndex(当前元素索引，可选)、array(数组，可选); initialValue(初始值，可选)

[2, 4, 6].reduce(function(acc, cur, index, arr){
	// console.log('累计值为'+acc+' 当前值为'+cur+' 当前索引为'+index);
	// console.log(arr); //可以查看打印的相关参数
	return acc + cur;
}); // 12 所有元素相加的值

// 有初始值的情况  =>写法
[2, 4, 6].reduce((acc, cur) => acc + cur, 10); // 22 初始值10+所有元素相加的值

// 还可以用于数组合并
[[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
    return a.concat(b);
}); // [0, 1, 2, 3, 4, 5]

// 数组中元素的最大值
[1,2,5,6,3].reduce((acc,cur)=>{
	return Math.max(acc, cur);
}); // 6