1.转换方法 toString() valueOf() join()

toString()方法会返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串。
valueOf()返回的还是数组
join()传递参数以自定义分隔符

let arr = ["a", "b", 1, 3, 6]
console.log(arr.toString())  // a,b,1,3,6
console.log(arr.valueOf())   // ["a", "b", 1, 3, 6]
console.log(arr.join(","))   // a,b,1,3,6
console.log(arr.join("/"))   // a/b/1/3/6

2.栈方法(栈是一种 LIFO（Last-In-First-Out，后进先出）的数据结构) push()和 pop()

push()方法可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。
pop()方法则从数组末尾移除最后一项，减少数组的 length 值，然后返回移除的项。

let colors = ["red", "green", "blue"]
let count = colors.push("black")
console.log(count)  // 4
let item = colors.pop()
console.log(item)  // black

3.队列方法(先进先出) shift() unshift() 和 push() 方法可以像使用队列一样使用数组

push()方法可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。
unshift()它能在数组前端添加任意个项并返回新数组的长度
shift()它能够移除数组中的第一个项并返回该项，同时将数组长度减 1。

let colors = ["red", "green", "blue"]
let count = colors.push("black")
console.log(count);   // 4

let item = colors.shift()
console.log(item)    // red
console.log(colors)  //["green", "blue", "black"]


let count1 = colors.unshift("yellow");
console.log(count1)     // 4
console.log(colors)    // ["yellow", "green", "blue", "black"]

4.重排序方法 reverse() 和 sort()

reverse()方法会反转数组项的顺序
sort()方法(在默认情况下)按升序排列数组项,sort()方法会调用每个数组项的 toString()转型方法，然后比较得到的字符串，以确定如何排序。即使数组中的每一项都是数值，sort()方法比较的也是字符串

// 反转
let values = [0, 1, 5, 10, 15]
values.reverse()
console.log(values)  /// [15, 10, 5, 1, 0]


let values = [0, 1, 5, 10, 15]
values.sort()
console.log(values) // [0, 1, 10, 15, 5]

//升序
values.sort((a, b) => a - b)
console.log(values) // [0, 1, 5, 10, 15]

//降序
values.sort((a, b) => b - a)
console.log(values) // [15, 10, 5, 1, 0]

5.操作方法 concat() slice() splice()

concat() 创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。
slice() 它能够基于当前数组中的一或多个项创建一个新数组。slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。

// concat()
let colors = ["red", "green", "blue"]
let colors2 = colors.concat(["black", "brown"])
console.log(colors)     // 原数组不变 ["red", "green", "blue"]
console.log(colors2)    // ["red", "green", "blue", "black", "brown"]

//slice()
let colors = ["red", "green", "blue", "yellow", "purple"];
let colors3 = colors.slice(1)
let colors4 = colors.slice(1, 4)
console.log(colors3) //["green", "blue", "yellow", "purple"]
console.log(colors4) //["green", "blue", "yellow"]

// 注意:如果 slice()方法的参数中有一个负数，则用数组长度加上该数来确定相应的位
// 置。例如，在一个包含 5 项的数组上调用 slice(-2,-1)与调用 slice(3,4)得到的
// 结果相同。如果结束位置小于起始位置，则返回空数组

splice() 方法始终都会返回一个数组，该数组中包含从原始数组中删除的项（如果没有删除任何项，则返回一个空数组）
- 删除：可以删除任意数量的项，只需指定2个参数：要删除的第一项的位置和要删除的项数。例如，splice(0,2)会删除数组中的前两项。
- 插入：可以向指定位置插入任意数量的项，只需提供3个参数：起始位置、0（要删除的项数）和要插入的项。如果要插入多个项，可以再传入第四、第五，以至任意多个项。例如，splice(2,0,"red","green")会从当前数组的位置 2 开始插入字符串"red"和"green"。
- 替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定3个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如，splice (2,1,"red","green")会删除当前数组位置 2 的项，然后再从位置 2 开始插入字符串"red"和"green"。

let colors = ["red", "green", "blue"]
let removed = colors.splice(0, 1) // 删除第一项
console.log(colors) //["green", "blue"]
console.log(removed) //["red"] 返回删除的项

let remo = colors.splice(1, 0, "yellow", "orange") // 从位置 1 开始插入两项
console.log(colors)  // ["green", "yellow", "orange", "blue"]
console.log(remo) // [] 返回删除的项没删除所以为空

6.位置方法 indexOf() 和 lastIndexOf()

这两个方法都接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。这两个方法都返回要查找的项在数组中的位置，
indexOf()方法从数组的开头（位置 0）开始向后查找
lastIndexOf()方法则从数组的末尾开始向前查找。

let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]
console.log(numbers.indexOf(4))  //3
console.log(numbers.lastIndexOf(4)) //5

7.迭代方法

every()：对数组中的每一项运行给定函数，如果该函数对每一项都返回 true，则返回 true
filter()：对数组中的每一项运行给定函数，返回该函数会返回 true 的项组成的数组。
forEach()：对数组中的每一项运行给定函数。这个方法没有返回值
map()：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。
some()：对数组中的每一项运行给定函数，如果该函数对任一项返回 true，则返回 true。

let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]

let everyNum = numbers.every(function(item, index) {
  return item > 0
})
console.log(everyNum)  //true

let someNum = numbers.some(function(item, index) {
  return item > 3
})
console.log(someNum) //true

let filterNum = numbers.filter(function(item, index) {
  return item > 1
})
console.log(filterNum) // [2, 3, 4, 5, 4, 3, 2]

let mapNum = numbers.map(function(item, index) {
  return item * 2
});
console.log(mapNum) // [2, 4, 6, 8, 10, 8, 6, 4, 2]

//forEach和for一样就是单纯的循环数组
numbers.forEach(function(item, index, array) {
  //执行某些操作
})

8.归并方法 reduce()和 reduceRight()。这两个方法都会迭代数组的所有项，然后构建一个最终返回的值

reduce() 方法从数组的第一项开始，逐个遍历到最后。
reduceRight() 则从数组的最后一项开始，向前遍历到第一项。
这两个函数返回的任何值都会作为第一个参数自动传给下一项。

let values = [1, 2, 3, 4, 5]
let sum = values.reduce(function(prev, cur, index, array) {
  return prev + cur
})
let sum1 = values.reduce(function(prev, cur, index, array) {
  return prev * cur
})
let sum2 = values.reduceRight(function(prev, cur, index, array) {
  return prev + cur
})
let sum3 = values.reduceRight(function(prev, cur, index, array) {
  return prev * cur
})

console.log(sum) // 15        1+2+3+4+5 = 15
console.log(sum1) // 120      1*2*3*4*5 = 120
console.log(sum2) // 15       5+4+3+2+1 = 15
console.log(sum3) // 120      5*4*3*2*1 = 120

参考：高级程序设计三