数组操作方法

shift

shift: 删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined 

  1. var a = [1,2,3,4,5];
  2. var b = a.shift(); // a:[2,3,4,5]   b:1

unshift

unshift: 将参数添加到原数组开头，并返回数组的长度

  1. var a = [1,2,3,4,5];
  2. var b = a.unshift(-2, -1);  // a:[-2,-1,1,2,3,4,5]   b:7

pop

pop: 删除原数组最后一项，并返回删除元素的值；如果数组为空则返回undefined 

  1. var a = [1,2,3,4,5];
  2. var b = a.pop();  // a:[1,2,3,4]   b:5

push

push: 将参数添加到原数组末尾，并返回数组的长度 

  1. var a = [1,2,3,4,5];
  2. var b = a.push(6,7);   // a:[1,2,3,4,5,6,7]   b:7

concat

concat: 数组拼接，将参数添加到原数组中，返回一个新数组。

  1. var a = [1,2,3,4,5];
  2. var b = a.concat(6,[7,8]);  // a:[1,2,3,4,5]   b:[1,2,3,4,5,6,7,8]

splice

splice(start,deleteCount,val1,val2,…):从start位置开始删除deleteCount项，并从该位置起插入val1,val2,…
从数组中添加/删除项目，然后返回被删除的项目。

  1. var a = [1,2,3,4,5];   
  2. var b = a.splice(2,2,7,8,9); //a:[1,2,7,8,9,5] b:[3,4]   
  3. var b = a.splice(0,1); //同shift   
  4. a.splice(0,0,-2,-1); var b = a.length; //同unshift   
  5. var b = a.splice(a.length-1,1); //同pop   
  6. a.splice(a.length,0,6,7); var b = a.length; //同push

slice

slice(start,end):返回从原数组中指定开始下标到结束下标之间的项组成的新数组 

  1. var a = [1,2,3,4,5];   
  2. var b = a.slice(2,5); //a:[1,2,3,4,5] b:[3,4,5]

sort

sort: 排序，给sort方法传递一个比较函数。该函数决定了它的两个参数在排好序的数组中的先后顺序：假设第一个参数应该在前，比较函数应该返回一个小于0的数值，反之，假设第一个参数应该在后，函数应该返回一个大于0的数值，并且，假设两个值相等，函数应该返回0。

  1. var a = [2,3,1,5]
  2. var b = a.sort(); // a:[1,2,3,5]  b:[1,2,3,5]
  3. a.sort(function(a, b){
  4.   if(a < b){
  5.     return -1;
  6.   }
  7.   else if (a > b) {
  8.     return 1;
  9.   }
  10.   else{
  11.     return 0;
  12.   }
  13. })

reverse

reverse: 将数组反序。

  1. var a = [1,2,3,4,5];   
  2. var b = a.reverse(); //a:[5,4,3,2,1] b:[5,4,3,2,1]

join

join(separator): 将数组的元素组起一个字符串，以separator为分隔符，省略的话则用默认用逗号为分隔符。

  1. var a = [1,2,3,4,5];   
  2. var b = a.join("|"); //a:[1,2,3,4,5] b:"1|2|3|4|5"

map

数组遍历方法，返回一个新数组，原数组不会改变。

forEach

数组遍历方法，返回值是undefined，不可以链式调用。

for in、for of

扩展运算符

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

reduce

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。

Array.form()

Array.from方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map）。
还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组。

  1. Array.from([1, 2, 3], (x) => x * x)     // [1, 4, 9]

Array.of()

Array.of方法用于将一组值，转换为数组。

  1. Array.of(3, 11, 8) // [3,11,8]

数组实例的 copyWithin()

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

  1. [1, 2, 3, 4, 5].copyWithin(0, 3);   // [4, 5, 3, 4, 5]

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

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

  1. [1, 4, -5, 10].find((n) => n < 0);     // -5
  2. [NaN].indexOf(NaN)
  3. // -1
  4. [NaN].findIndex(y => Object.is(NaN, y))
  5. // 0

数组实例的 fill()

fill方法使用给定值，填充一个数组。

  1. ['a', 'b', 'c'].fill(7)
  2. // [7, 7, 7]
  3. new Array(3).fill(7)
  4. // [7, 7, 7]

数组实例的 entries()，keys() 和 values() § ⇧

ES6 提供三个新的方法——entries()，keys()和values()——用于遍历数组。它们都返回一个遍历器对象（详见《Iterator》一章），可以用for…of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。

  1. for (let index of ['a', 'b'].keys()) {
  2.   console.log(index);
  3. }
  4. // 0
  5. // 1
  6. for (let elem of ['a', 'b'].values()) {
  7.   console.log(elem);
  8. }
  9. // 'a'
  10. // 'b'
  11. for (let [index, elem] of ['a', 'b'].entries()) {
  12.   console.log(index, elem);
  13. }
  14. // 0 "a"
  15. // 1 "b"

数组实例的 includes()

Array.prototype.includes方法返回一个布尔值，表示某个数组是否包含给定的值。
该方法的第二个参数表示搜索的起始位置，默认为0。如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度。

  1. [1, 2, 3].includes(3, 3);  // false
  2. [1, 2, 3].includes(3, -1); // true

ES5 对空位的处理，已经很不一致了，大多数情况下会忽略空位。

forEach(), filter(), reduce(), every() 和some()都会跳过空位。
map()会跳过空位，但会保留这个值
join()和toString()会将空位视为undefined，而undefined和null会被处理成空字符串。

  1. // forEach方法
  2. [,'a'].forEach((x,i) => console.log(i)); // 1
  3. // filter方法
  4. ['a',,'b'].filter(x => true) // ['a','b']
  5. // every方法
  6. [,'a'].every(x => x==='a') // true
  7. // reduce方法
  8. [1,,2].reduce((x,y) => x+y) // 3
  9. // some方法
  10. [,'a'].some(x => x !== 'a') // false
  11. // map方法
  12. [,'a'].map(x => 1) // [,1]
  13. // join方法
  14. [,'a',undefined,null].join('#') // "#a##"
  15. // toString方法
  16. [,'a',undefined,null].toString() // ",a,,"

数组实例的 flat()，flatMap()

Array.prototype.flat()用于将嵌套的数组“拉平”，变成一维的数组。该方法返回一个新数组，对原数据没有影响。
默认只会“拉平”一层，如果想要“拉平”多层的嵌套数组，可以将flat()方法的参数写成一个整数，表示想要拉平的层数，默认为1。

  1. [1, 2, [3, 4]].flat();   // [1, 2, 3, 4]
  2. [1, 2, [3, [4, 5]]].flat();  // [1, 2, 3, [4, 5]]
  3. [1, 2, [3, [4, 5]]].flat(2);  // [1, 2, 3, 4, 5]

flatMap()方法对原数组的每个成员执行一个函数（相当于执行Array.prototype.map()），然后对返回值组成的数组执行flat()方法。该方法返回一个新数组，不改变原数组。

  1. // 相当于 [[2, 4], [3, 6], [4, 8]].flat()
  2. [2, 3, 4].flatMap((x) => [x, x * 2])    // [2, 4, 3, 6, 4, 8]