数组方法

创建数组：

// 字面量方式:
var a = [3, 11, 8];
// [3,11,8];
// 构造器:
// 实际上 new Array === Array,加不加new 一点影响都没有。
var a = Array();
// []
var a = Array(3);
// [,,]
var a = Array(3,11,8);
// [ 3,11,8 ]

Array.of(element0[, element1[, ...[, elementN]]])

定义： 返回由所有参数组成的数组，如果没有参数，就返回一个空数组。
目的：为了解决Array()参数个数不同导致行为有差异的问题

let a = Array.of(3, 11, 8);
// [3,11,8]
let a = Array.of(3);
// [3]

Array.from(arrayLike[, mapFn[, thisArg]])

定义：从一个类似数组或可迭代对象中创建一个新的数组实例。
arrayLike：想要转换成数组的伪数组对象或可迭代对象。
mapFn (可选参数)： 如果指定了该参数，新数组中的每个元素会执行该回调函数。
thisArg (可选参数)：执行回调函数 mapFn 时 this 对象。

方法

数组方法大致可分为三类：1. 改变原数组的值；2. 不改变原数组；3. 数组的遍历方法。

1. 改变原数组（9个）

let a = [1,2,3];
// ES5:
a.splice(); // 删除/添加元素
a.sort(); // 排序
a.pop();  // 删除数组中最后一个元素
a.shift(); // 删除数组中第一个元素
a.push(); // 向数组的末尾添加元素
a.unshift(); // 向数组的头部添加元素
a.reverse(); // 倒序
// ES6:
a.copyWithin(); 
a.fill();

array.splice(start[, deleteCount[, item1[, item2[, ...]]]])

定义： splice()方法向/从数组中添加/删除项目，返回被删除的项目
参数：
start​：指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数）；若只使用start参数而不使用deleteCount、item，如：array.splice(start)，表示删除[start，end]的元素。
deleteCount 可选：整数，表示要移除的数组元素的个数。如果 deleteCount 是 0，则不移除元素。这种情况下，至少应添加一个新元素。如果 deleteCount 大于start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。如果deleteCount被省略，则其相当于arr.length - start。
item1, item2, ... 可选：要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。

const a = [1, 2, 3, 4, 5, 6, 7];
// 删除
a.splice(0,3); // [1,2,3]
// 添加
a.splice(0, 0, '添加'); // ["添加", 1, 2, 3, 4, 5, 6, 7]
// 删除并添加
a.splice(0, 3, '添加'); // ["添加", 4, 5, 6, 7]

arr.copyWithin(target[, start[, end]])

定义： 浅复制数组的一部分到同一数组中的另一个位置，并返回它，而不修改其大小。
参数：
target： 0 为基底的索引，复制序列到该位置。如果是负数，target 将从末尾开始计算。
如果 target大于等于 arr.length，将会不发生拷贝。如果 target 在start 之后，复制的序列将被修改以符合 arr.length。
start 可选： 0 为基底的索引，开始复制元素的起始位置。如果是负数，start 将从末尾开始计算。
如果 start 被忽略，copyWithin 将会从0开始复制。
end 可选： 0 为基底的索引，开始复制元素的结束位置。copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素。如果是负数，end 将从末尾开始计算。
如果 end 被忽略，copyWithin 将会复制到 arr.length。

const a = [1, 2, { b: 3 }];
a.copyWithin(0, 2);
a[2].c = 4;
console.log(a); //  [{ b: 3, c: 4 }, 2, { b: 3, c: 4 }]

arr.fill(value[, start[, end]])

value：用来填充数组元素的值。
start 可选： 起始索引，默认值为0。
end 可选： 终止索引，默认值为 this.length。

const a = [1, 2, 3, 4, 5, 6, 7];
a.fill(8, 0, 1);  // [8, 2, 3, 4, 5, 6, 7]

其他的例子

const a = [1, 2, 3, 4];
a.sort((v1, v2) => (v2 - v1)); // [4, 3, 2, 1]
a.pop(); // [1, 2, 3]
a.shift(); // [2, 3, 4]
a.push([5]); // [1, 2, 3, 4, [ 5 ]]
a.unshift(0); // [0, 1, 2, 3, 4]
a.reverse(); // [4, 3, 2, 1]

2. 不改变原数组的方法(8个):

// ES5：
a.slice() // 浅拷贝数组的元素
a.join() // 数组转字符串
a.toLocaleString() // 每个元素调用toLocateString()然后join(',')
a.toString() // 每个元素调用toString()然后join(',')
a.concat() // 连接数组
a.indexOf()
a.lastIndexOf()

// ES7
includes

a.concat(value1[, value2[, ...[, valueN]]])

创建一个新的数组，它由被调用的对象中的元素组成，每个参数的顺序依次是该参数的元素（如果参数是数组）或参数本身（如果参数不是数组）。它不会递归到嵌套数组参数中。

知识点：利用concat可以扁平化多维数组

const flattenArray = array => ([].concat(...array.map(v => (Array.isArray(v) ? flattenArray(v) : v))));
const a = [1, [2, [3, [4]]]];
flattenArray(a);

a.includes(searchElement[, fromIndex])

定义：判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。searchElement为需要查找的元素， fromIndex为查找开始的位置，精确匹配
好处：
弥补indexOf不能识别NaN的缺陷。
表达直观，indexOf必须要判断是否等于-1， 。

const a = [1, 2, 3, NaN];
a.includes(NaN); // true
a.indexOf(NaN); // -1

其他例子

const a = [1, 2, 3, 4];
console.log(a.slice(1, 2)); // [2]
console.log(a.join('-')); // 1-2-3-4
console.log(a.toLocaleString()); // 1,2,3,4
console.log(a.toString()); // 1,2,3,4
console.log(a.indexOf('2')); // -1
console.log(a.indexOf(2)); // 1
console.log(a. lastIndexOf(2)); // 1

3. 遍历方法(12个):

// ES5： forEach、every 、some、 filter、map、reduce、reduceRight
// ES6： find、findIndex、keys、values、entries

forEach、every 、some、 filter、map、find、findIndex

这几个方法参数是一样的，区别是返回值不同。

a.map(function(currentValue, index, arr), thisArg)
currentValue为当前遍历的每一个元素的值，index为元素下边，arr为整个数组，thisArg为绑定的this上下文。

定义
forEach() 全局遍历对象， 无返回值
map() 全局遍历对象， 根据function返回相应的数组
every() 检测数组所有元素是否都符合条件， 只要有一项不符合即返回false其余项不再检测，否则返回true。
forEach() 检测数组所有元素是否都符合条件， 只要有一项符合即返回true其余项不再检测，否则返回false。
filter() 返回符合条件的数组的元素
find() 找出第一个符合条件的数组成员，并返回该成员，如果没有符合条件的成员，则返回undefined。
findIndex() 同上不同的时候返回的是该数组的index下标

a.reduce(function(accumulator, currentValue, currentIndex, arr)[, initialValue]);

累加器，对数组中的每个元素（从左到右）应用一个函数，将其减少为单个值
accumulator为累加器返回的累积值， currentValue为当前处理的元素值，currentIndex为当前处理的元素的index，initialValue为第一次调用的时候的初始值， 如果没有则使用第一个值

const a = [1, 2, 3, 4];
const b = a.reduce((total, v) => (total + v), 10);
const c = a.reduce((total, v) => (total + v));
console.log(b); // 20
console.log(c); // 10

a.reduceRight(function(accumulator, currentValue, currentIndex, arr)[, initialValue]);

同上，区别是从右到左。

keys()&values()&entries() 遍历键名、遍历键值、遍历键名+键值

返回值为Array迭代器，不能用for循环或者forEach循环，可用Array.from转化为普通数组或者for...of遍历

const a = [1, 2, 3, 4];
const b = a.keys();
const c = a.values();
const d = a.entries();
console.log(Object.prototype.toString.call(b)); // [object Array Iterator]
console.log(Array.from(b)); // [0, 1, 2, 3]
console.log(Array.from(c)); // [1, 2, 3, 4]
console.log(Array.from(d)); // [[0, 1], [1, 2], [2, 3], [3, 4]]