Array.prototype.pop()

删除数组最后一个元素，并返回该元素的值。
如果在一个空数组上调用pop(), 它返回undefined.

Array.prototype.push()

将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

  1. var sports = ['soccer', 'baseball']
  2. var total = sports.push('football', 'swimming') // ['soccer', 'baseball', 'football', 'swimming']

合并两个数组
使用apply() 添加第二个数组的所有元素
当第二个数组太大时不要使用这个方法来合并数组，事实上一个函数能够接受的参数个数是有限制的。

  1. var vegetables = ['parsnip', 'potata']
  2. var moreVegs = ['celery', 'beetroot']
  4. Array.prototype.push.apply(vegetables, moreVegs)
  5. console.log(vegetables) // ['parsnip', 'potato', 'celery', 'beetroot']

Array.prototype.reduce()

reduce() 对数组中的每个元素执行一个由你提供的reducer函数（升序执行），将其结果汇总为单个返回值。
reducer 函数接收4个参数：
acc 累计器
cur 当前值
idx 当前索引
src 源数组

返回值： 函数累计处理的结果

示例：

  1. // 数组里所有值的和
  2. let arr = [0, 1, 2, 3]
  3. var total = arr.reduce((acc, cur) => acc + cur, 0) 
  5. // 累加对象数组里的值
  6. let sum = [{x: 1}, {x: 2}, {x: 3}].reduce((acc, cur) => acc + cur.x, 0)
  8. // 二维数组转化为一维
  9. var flattened = [[0, 1], [2, 3], [4, 5]].reduce((acc, cur) => acc.concat(cur), [])
  11. // 计算数组中每个元素出现的次数
  12. var names = ['Alice', 'Bob', 'Tiff', 'Brue', 'Alice']
  13. var countNames = names.reduce(function(allNames, name) {
  14.     if (name in allNames) {
  15.       allNames[name]++
  16.   } else {
  17.       allNames[name] = 1
  18.   }
  19.   return allNames
  20. }, {})
  21. // {'Alice': 2, 'Bob': 1, 'Bruce': 1}

按属性对Object 分类

  1. var people = [
  2.     {name: 'Alice', age: 21},
  3.   {name: 'Max', age: 20},
  4.   {name: 'Jane', age: 20}
  5. ]
  6. function groupBy(objArr, property) {
  7.     return objArr.reduce(function(acc, obj) {
  8.       var key = obj[prototype];
  9.     if (!acc[key]) {
  10.         acc[key] = []
  11.     }
  12.     acc[key].push(obj)
  13.     return acc
  14.   }, {})
  15. }
  17. var groupedPeople = groupBy(people, 'age')

使用扩展运算符将数组对象中的数组合并成一个新的 数组

  1. var friends = [{
  2.   name: 'Anna',
  3.   books: ['Bible', 'Harry Potter'],
  4.   age: 21
  5. }, {
  6.   name: 'Bob',
  7.   books: ['War and peace', 'Romeo and Juliet'],
  8.   age: 26
  9. }, {
  10.   name: 'Alice',
  11.   books: ['The Lord of the Rings', 'The Shining'],
  12.   age: 18
  13. }];
  15. var allbooks = friends.reduce(function(prev, curr) {
  16.     return [...prev, ...curr.books]
  17. }, ['Alphabet'])

数组去重

  1. let arr = [1, 2, 1, 2, 3, 4, 5, 3, 4, 4, 4]
  2. let result = arr.sort().reduce((init, current) => {
  3.     if (init.length === 0 || init[init.length - 1] === current) {
  4.       init.push(current)
  5.   }
  6.   return init
  7. }, [])
  8. // result [1, 2, 3, 4, 5]

Array.prototype.reduceRight()

reduceRight() 接受一个函数作为累加器和数组的每个值（从右到左）将其减少为单个值。

示例：

  1. // 求一个数组中所有值的和
  2. var total = [0, 1, 2, 3].reduceRight(function(a, b) {
  3.     return a + b
  4. })
  6. // 扁平化
  7. var flattened = [[0, 1], [2, 3], [4, 5]].reduceRigth(function(a, b) {
  8.     return a.concat(b)
  9. }, [])
  10. // [4, 5, 2, 3, 0, 1]

reduce 与 reduceRight 之间的区别

  1. var a = ['1', '2', '3', '4', '5']
  2. var left = a.reduce(function(prev, cur) { return prev + cur }) // left: '12345'
  3. var right = a.reduceRight(function(prev, cur) { return prev + cur })  // right: '54321'

Array.prototyp.reverse()

将数组中元素的位置颠倒，并返回该数组。该方法会改变原数组。

  1. var sourceArray = ['one', 'two', 'three']
  2. var reverseArray = sourceArray.reverse()

Array.prototype.shift()

shift() 从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
如果数组为空返回undefined.

Array.prototype.slice()

【包左不包右】
slice() 返回一个新的数组对象，这一对象是一个由begin 和 end 决定的原数组的浅拷贝。原数组不会被改变。

如果该元素是个对象引用，slice 会拷贝这个对象引用到新的数组里。两个对象引用都引用了同一个对象。如果被引用的对象发生改变，则新的和原来的数中的这个元素也会发生改变。

  1. // 语法
  2. arr.slice(); [0, end]
  3. arr.slice(begin);  [begin, end]
  4. arr.slice(begin, end); [begin, end]

Array.prototype.some()

some() 测试是否至少有一个元素通过由提供的函数实现的测试。
对于放在空数组上的任何调价，此方法返回 false

返回值： boolean

  1. console.log([2, 3, 4].some(v => v > 4));

Array.portotype.sort()

sort() 用原地算法对数组的元素进行排序，并返回数组。

比较数字而非字符串，比较函数可以简单以 a - b.

  1. var numbers = [4, 2, 5, 1, 3]; 
  2. numbers.sort((a, b) => a - b)  // [1, 2, 3, 4, 5]
  3. numbers.sort((a, b) => b - a); //  [5, 4, 3, 2, 1]

Array.prototype.splice()

splice() 通过删除或替换现有元素来修改数组，并以数组形式返回被修改的内容。此方法会改变原数组。

  1. array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
  3. //返回值 由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。
  4. 如果没删除元素，则返回空数组。

示例：

  1. // 从第二位开始删除0个元素，插入‘drum’
  2. var myFish = ['angel', 'clown', 'mandarin', 'surgeon']
  3. var removed = myFish.splice(2, 0, 'drum')
  4. // myFish  ['angel', 'clown', 'drum', 'mandarin', 'surgeon']
  5. // removed []
  7. // 从第二为开始删除0个元素，插入‘drum’和 ‘guitar’
  8. var myFish2 = ['angel', 'clown', 'mandarin', 'surgeon']
  9. var removed2 = myFish.splice(2, 0, 'drum', 'guitar')
  11. // 从第三位开始删除1个元素
  12. var myFish3 = ['angel', 'clown', 'mandarin', 'surgeon']
  13. var rmoved3 = myFish3.splice(3, 1)
  15. // 从第四为开始删除1位元素，插入‘trumpet’
  16. var myFish5 = ['angel', 'clown', 'mandarin', 'surgeon']
  17. var removed5 = myFish5.splice(2, 1, 'trumpet')
  19. // 从第0位开始删除2个元素，插入‘parrot’， ‘anemone’ 和 ‘blue’
  20. var myFish6 = ['angel', 'clown', 'mandarin', 'surgeon']
  21. var removed6 = myFish6.splice(0, 2, 'parrot', 'anemone', 'blue')
  23. // 从第2位开始删除2个yuans
  24. var myFish7 = ['angel', 'clown', 'mandarin', 'surgeon']
  25. var removed7 = myFish7.splice(2, 2)
  27. // 从倒数第2位开始删除1个元素
  28. var myFish8 = ['angel', 'clown', 'mandarin', 'surgeon']
  29. var removed8 = myFish8.splice(-2, 1)
  31. // 从第2位开始删除所有元素
  32. var myFish9 = ['angel', 'clown', 'mandarin', 'surgeon']
  33. var removed9 = myFish9.splice(2)

Array.prototype.toString()

toString() 返回一个字符串，标识制定的数组及其元素。

  1. var arr1 = [1, 2, 'a', '1a']
  2. let output = array1.toString()  // '1,2,a,1a'

Array.prototype.unshift()

unshift() 将一个或多个元素添加到数组的开头，并返回该数组的新长度。

  1. arr.unshift(alement1, ..., elementN)
  3. var arr = [1, 2]
  4. arr.unshift(0)  // arr => [0, 1, 2]；  返回 3
  6. var arr1 = [1, 2]
  7. arr1.unshift(-2, -1) // arr1 => [-2, 1, 1, 2]; 返回 4
  9. var arr2 = [1, 2]
  10. arr2.unshift([-3])  // arr2 => [[-3], 1, 2]; 返回 3

Array.prototype.values()

values() 返回一个新的Array Iterator 对象，该对象包含数组每个索引的值。

  1. // 使用 for .. of 循环进行迭代
  2. let arr = ['w', 'y', 'k', 'o', 'p']
  3. let eArr = arr.values()
  5. for (let letter of eArr) {
  6.     console.log(letter)
  7. }
  9. // 另一种迭代方式
  10. let arr = ['w', 'y', 'k', 'o', 'p'];
  11. let eArr = arr.values()
  12. console.log(eArr.next().value); // w
  13. console.log(eArr.next().value); // y
  14. console.log(eArr.next().value); // k
  15. console.log(eArr.next().value); // o
  16. console.log(eArr.next().value); // p

多维数组转一维数组

// 使用generator函数

  1.           let arr = [1, [[2, [0, [0, 2, 0], 1, 9], 3], 4], [5, 6]]
  2.       let flat = function* (a) {
  3.         let len = a.length
  4.         for (let i = 0; i < len; i++) {
  5.           let item = a[i]
  6.           if (typeof item !== "number") {
  7.             yield* flat(item)
  8.           } else {
  9.             yield item
  10.           }
  11.         }
  12.       }
  13.       let flatArr = flat(arr)

// for 循环

  1.       let arr = [1, [[2, [0, [0, 2, 0], 1, 9], 3], 4], [5, 6]];
  2.       let result = [];
  3.       function swtichArr(arr = []) {
  4.         for (let item of arr) {
  5.           if (Array.isArray(item)) {
  6.             swtichArr(item)
  7.           } else {
  8.             result.push(item)
  9.           }
  10.         }
  11.         return result;
  12.       }
  13.       console.log(swtichArr(arr))

// reduce

  1.     let arrTwo = [[0, 1], [2, [7, 8], 3], [4, 5]];
  2.     function reduceFlatArr(arr) {
  3.       return arr.reduce((acc, cur) =>  Array.isArray(cur) ? acc.concat(reduceFlatArr(cur)) : acc.concat(cur), [])
  4.     }
  5.     console.log('reduceFlatArr', reduceFlatArr(arrTwo))