Array.prototype.at()

at(index)

at()方法接收一个索引，并返回该索引所对应的元素，当index为正数时，array.at(index) === array[index]。当index为负数是，从数组的最后一个元素倒数。 at接收负数而[]不接收负数；

let a = [0,1,2,3];
a.at(0) === a[0];//true

a.at(-1); //3
a[-1];    //undefined

a.at(-1) === a[a.length - 1]; //3  使用at更简洁

Array.prototype.concat()

var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])

concat()合并数组，concat()不改变原有数组，而是返回新数组。

let a1 = [1,2,3];
let a2 = [4,5,6];
let a3 = a1.concat(a2);  //[1,2,3,4,5,6]

let a4 = [7,8,9];
let a5 = a1.concat(a2,a4); //[1,2,3,4,5,6,7,8,9]
let a6 = a1.concat(a2).concat(a4); //[1,2,3,4,5,6,7,8,9]

Array.prototype.copyWithin()

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

copyWithin()将数组的某一部分浅复制到该数组的另一位置并返回该数组，不会改变原数组长度。

let a1 = [0,1,2,3,4,5,6];
a1.copyWithin(0,1,2) //[1,1,2,3,4,5,6]，将索引1处的元素复制到索引0的位置
a1.copyWithin(0,1,3) //[1,2,2,3,4,5,6]，将索引1和索引2的元素复制到索引0的位置
a1.copyWithin(0,1)   //[1,2,3,4,5,6,6]，将索引1包括其之后的所有元素复制到索引0的位置

Array.prototype.entries()

arr.entries(): object

entries()，入口，返回数组的一个迭代器(Array Iterator)对象，该对象包含数组中每个索引的键/值对。

var arr = ["a", "b", "c"];
var iterator = arr.entries();
console.log(iterator.next());

/*{value: Array(2), done: false}
          done:false
          value:(2) [0, "a"]
           __proto__: Object
*/
// iterator.next() 返回一个对象，对于有元素的数组，
// 是 next{ value: Array(2), done: false }；
// next.done 用于指示迭代器是否完成：在每次迭代时进行更新而且都是 false，
// 直到迭代器结束 done 才是 true。
// next.value 是一个 ["key","value"] 的数组，是返回的迭代器中的元素值。
console.log(iterator.next().value); //[0,"a"]
console.log(iterator.next().value); //[1,"b"]
...

Array.prototype.every()

arr.every(callback(element[, index[, array]])[, thisArg]): boolean

every()检验数组中每一个元素是否通过某个函数的测试，返回布尔值；

let a = [1,2,3,4,5,6];
a.every((element, index, array) => element < 7); // true

Array.prototype.fill()

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

fill()用某个值填充数组中从起始索引到终止索引内的所有元素，不包括终止索引，若索引为负数，则换算为length+index。

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

Array.prototype.filter()

var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])

filter()，过滤，传入一个方法，将满足该方法的数组元素过滤进一个新的数组。

let a = [1,2,3,4];
let result = a.filter((element, index, array) => element < 4); //[1,2,3]

Array.prototype.find()

arr.find(callback[, thisArg])

find()，寻找值，传入一个方法，找出满足该方法的第一个元素的值。否则返回undefined

let a = [1,2,3,13,23,44]
let result = a.find((element, index, array) => element > 10);  //13

Array.prototype.findLast()

arr.findLast(callback[, thisArg])

findLast()，寻找值（最后一个），传入一个方法，找出满足该方法的最后一个元素的值。否则返回undefined。

let a = [1,2,3,13,23,44]
let result = a.findLast((element, index, array) => element > 10);  //44

Array.prototype.findIndex()

arr.findIndex(callback[, thisArg])

findIndex()，寻找索引，传入一个方法，找出满足该方法的第一个元素的索引。否则返回-1

let a = [1,2,3,13,23,44]
let result = a.find((element, index, array) => element > 10);  //3

Array.prototype.findLastIndex()

arr.findIndex(callback[, thisArg])

findIndex()，寻找索引（最后一个），传入一个方法，找出满足该方法的最后一个元素的索引。否则返回-1

let a = [1,2,3,13,23,44]
let result = a.find((element, index, array) => element > 10);  //5

Array.prototype.flat()

var newArray = arr.flat([depth])

flat()，数组扁平化，将传入的参数作为递归深度遍历数组，将数组的所有元素包括其子数组中的元素合并为一个新的数组并返回。

let a1 = [1,2,3,[4,5]]
a1.flat() //[1,2,3,4,5] 不传参默认的递归深度是1

let a2 = [1,2,3,[[[4,5]]]]
a2.flat(2) //[1,2,3,[4,5]]

Array.prototype.flatMap()

var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) { // return element for new_array }[, thisArg])

flatMap()传入一个映射函数，映射数组中的每一个元素，将映射结果放入一个新的数组。

let a1 = [1,2,[3],[4,5],6,[]];

let result = a1.flatMap((element, index, array) => element); //[1,2,3,4,5,6]

Array.prototype.forEach()

arr.forEach(callback(currentValue [, index [, array]])[, thisArg])

forEach()对数组的每个元素执行一次给定的函数，forEach()不可改变基本变量的值，可以改变引用变量中元素的值。

let a = [1,2,3]
a.forEach((element, index, array) => { element++; console.log(element); }); 
console.log(a)
// 2  
// 3  
// 4
// [1,2,3]
let a = [{name: 'tom'}, {name: 'jack'}]
a.forEach((element, index, array) => element.name = 'override');
console.log(a); //[{name: 'override'}]

Array.prototype.includes()

arr.includes(valueToFind[, fromIndex])

includes()传入要找的值以及开始查找的索引，判断数组是否包含传入的值，是则返回true，否则返回false；

let a = [1,2,3,4,5]
a.includes(2); //true
a.includes(2,2); //false
a.includes(0); //false

Array.prototype.indexOf()

arr.indexOf(searchElement[, fromIndex])

indexOf()传入要找的元素和开始查找的索引，返回从数组中所找到元素的第一个索引，如果不存在则返回-1。

let a = [1,2,3,1];
a.indexOf(1);   //1
a.indexOf(1,2); //3
a.indexOf(4);   //-1

Array.prototype.lastIndexOf()

arr.lastIndexOf(searchElement[, fromIndex])

lastIndexOf()传入要找的元素和开始查找的索引，返回从数组中所找到元素的最后一个索引，如果不存在则返回-1。

let a = [1,2,3,1];
a.lastIndexOf(1);   //3
a.lastIndexOf(1,2); //0
a.lastIndexOf(4);   //-1

Array.prototype.join()

arr.join([separator])

join()，连接，传入分隔符，将数组（或类数组对象）的元素根据分隔符连成一个字符串并返回。

let a = [1,2,3];
a.join();    //'1,2,3' 默认为逗号
a.join('');  //'123'
a.join('|'); //'1|2|3'

Array.prototype.keys()

arr.keys()

keys()，键，返回包含数组中所有键的迭代器对象；

let a = [1,2,3];
let iterator = a.keys();
for(let key of iterator) {
   console.log(key);
 }
 //0
 //1
 //2

Array.prototype.map()

var new_array = arr.map(function callback(currentValue[, index[, array]]) { // Return element for new_array }[, thisArg])

map()，映射，传入一个方法，将数组中元素执行方法后的返回值映射到一个新的数组。

let a = [1,2,3];
let result = a.map((element, index, array) => element*2); //[2,4,6]

Array.prototype.pop()

arr.pop()

pop()，弹出，删除数组的最后一个元素，并返回该元素的值。此方法会改变数组的长度。

let a = [1,2,3];
let result = a.pop();
console.log(a);      //[1,2]
console.log(result); //3

Array.prototype.push()

arr.push(element1, ..., elementN)

push()将一个或多个元素添加到数组的末尾，并返会数组的长度。

let a = [1,2,3];
let result = a.push(4,5);
console.log(a);      //[1,2,3,4,5]
console.log(result); //5

Array.prototype.reduce()

reduce((previousValue, currentValue, currentIndex, array) => { /* ... */ }, initialValue)

reduce()，归纳，传入一个归纳器（reducer），对数组中的每个元素按序执行reducer，每次执行方法会将返回值作为参数previousValue继续传入reducer，直到将结果汇总为单个返回值。可以设置初始值initialValue，否则数组的第一项将会作为初始值，迭代器从第二个元素开始执行。

let a = [1,2,3,4]
let initialValue = 0;
let sum = a.reduce((previousValue, currentValue) => previousValue + currentValue, initialValue);
coneole.log(sum) //10 (0+1+2+3+4)

Array.prototype.reduceRight()

arr.reduceRight(callback(accumulator, currentValue[, index[, array]])[, initialValue])

reduceRight()传入一个方法作为累加器（accumulator）和数组的每个当前值（从右到左），将其减少为单个值。

let a = [[0,1],[2,3],[4,5]]
let result = a.reduceRight((accumulator, currentValue, index, array) => accumulator.concat(currentValue), initialValue);
console.log(result); //[4,5,2,3,0,1]

Array.prototype.reverse()

arr.reverse()

reverse()，翻转，将数组中的元素的位置颠倒，并返回该数组。该方法改变原数组。

let a = [1,2,3];
console.log(a); //[1,2,3]
let result = a.reverse();
console.log(result); //[3,2,1]

Array.prototype.shift()

arr.shift()

shift()，移位，删除数组的第一个元素，并返回该元素的值。改变数组的长度。

let a = [1,2,3]
let firstElement = a.shift();
console.log(a); // [2,3]
console.log(firstElement); //1

Array.prototype.unshift()

arr.unshift(element1, ..., elementN)

unshift，将一个或多个元素添加到数组的开头，并返回该数组的新长度（改变原数组）。

let a = [1,2,3]
console.log(a.unshift(4,5)); //5
console.log(a);              //[4,5,1,2,3]

Array.prototype.slice()

arr.slice([begin[, end]])

slice()，切片，返回对原数组从begin到end（包括begin，不包括end）的一个切片（浅拷贝）。原数组不被改变。

let a = [0,1,2,3,4,5]
let result1 = a.slice(1); //[1,2,3,4,5]
let result2 = a.slice(2,4); //[2,3]

Array.prototype.some()

arr.some(callback(element[, index[, array]])[, thisArg])

some()，存在，传入一个测试方法，若数组中至少有一个元素通过方法的测试，则返回true，否则返回false。

let a = [1,2,3,4,5]
a.some((element, index, array) => element > 5); //false

Array.prototype.sort()

arr.sort([compareFunction])

sort()，排序，对数组元素进行排序并返回数组；默认排序顺序是在将元素转换为字符串，然后比较它们的 UTF-16 代码单元值序列时构建的

let a = [2,5,1,4,3];
a.sort(); //[1,2,3,4,5]
a.sort((a,b) => a-b); //[1,2,3,4,5] compareFunction(a,b)小于0，a排在b之前
a.sort((a,b) => b-a); //[5,4,3,2,1] compareFunction(a,b)大于0，a排在b之后

Array.prototype.splice()

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

splice()，移接，删除或替换数组的现有元素，或者原地添加新的元素来修改原数组。

let a = [1,3,4];
a.splice(1, 0 , 2); //[1,2,3,4]
let a1 = [1,6,6,4,5];
a.splice(1, 2, 2, 3); //[1,2,3,4,5]

Array.prototype.toLocaleString()

arr.toLocaleString([locales[,options]]);

let a = [1, 'a', new Date('21 Dec 1997 14:12:00 UTC')];
let localeString = a.toLocalString('en', { timeZone: 'UTC'});

console.log(localeString); //"1,a,12/21/1997, 2:12:00 PM"

Array.prototype.toString()

arr.toString()

toString()，返回一个字符串表示指定的数组及其元素。

let a = [1,2,3,4];
console.log(a.toString()); //"1,2,3,4"

Array.prototype.values()

arr.values()

values()返回一个iterator对象，该对象包含数组每个元素的值。

let a = [1,2,3]
let iterator = a.values();

for(let value of iterator){
   console.log(value);
}
//1
//2
//3

Array.from()

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

Array.from()，来自···的数组，对类数组对象(arguments)或可迭代对象(Map/Set)创建一个新的，浅拷贝的数组实例；

console.log(Array.from('1234')); //['1','2','3','4']
console.log(Array.from([1,2,3], x => x + x)); //[2,4,6]

Array.of()

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

Array.of()，由···组成的数组，创建一个具有任意数量参数的新数组实例，不考虑参数的数量或类型。

Array.of()  和 Array 构造函数之间的区别在于处理整数参数：Array.of(7)  创建一个具有单个元素 7 的数组，而 Array(7)  创建一个长度为 7 的空数组（注意：这是指一个有 7 个空位 (empty) 的数组，而不是由 7 个undefined组成的数组）。

Array.of(7); //[7]
Array(7);    //[ , , , , , , ]

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

Array.isArray()

Array.isArray(obj)

Array.isArray用来确定传入的参数是否是一个Array。

Array.isArray([1,2,3]);         //true
Array.isArray({foo: 123});      //false
Array.isArray('foobar');        //false
Array.isArray(new Array());     //true
Array.isArray(Array.prototype); //true