下面以var arr = ['x', 'u', 'e', 'y', 'i', 'n', 'g']为例
修改器方法：
修改器方法会改变原数组
1. arr.pop() && arr.push()
会改变原数组
arr.pop()删除数组最后一个元素，并返回这个元素
arr.pop() // "g"
arr.push()在数组末尾增加一个元素，返回数组的新长度
arr.push('l') // 8
arr // ["x", "u", "e", "y", "i", "n", "g", "l"]
2. arr.shift() && arr.unshift()
arr.shift() 删除数组开头第一个元素，并返回这个元素
arr.shift() // "x"
arr.unshift() 在数组开头增加一个元素，返回数组新长度。
arr.unshift('l') // 8
arr // ["l", "x", "u", "e", "y", "i", "n", "g"]
3. arr.reverse()
会改变原数组
数组倒序，返回倒序后的数组
arr.reverse() // ["g", "n", "i", "y", "e", "u", "x"]
4. arr.sort() || arr.sort(compareFunction)
对数组进行排序，并返回排好序的当前数组。（写得这么拗口是为了强调是原数组的顺序改变）
.sort()使用的是就地排序算法，且不一定稳定。
（就地排序意思是直接在原数组上排序。稳定指的是两个相等的元素排好序后前后顺序不变）
默认排序顺序是根据字符串Unicode码点。
这意味着：
var scores = [1, 10, 21, 2];
scores.sort(); // [1, 10, 2, 21]
// 10在2之前,因为在 Unicode 指针顺序中"10"在"2"之前
不过.sort()可以接受一个函数作为参数，自己指定排序规则：
var scores = [1, 10, 21, 2];
scores.sort(function (a, b) { // 从小到大排序
return a - b
}) // [ 1, 2, 10, 21 ]
函数compareFunction 的规则如下：
- 如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
- 如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。
备注： ECMAScript 标准并不保证这一行为，而且也不是所有浏览器都会遵守（例如 Mozilla 在 2003 年之前的版本）； - 如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。
- compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。
5. arr.splice(start, deleteCount, item1, item2, …)
修改数组，从start开始，删除deleteCount个元素，再插入后面的item1, item2, ...
// 从下标0开始，删除一个元素，并插入‘X'
arr.splice(0, 1, 'X') // ["x"]
arr // ["X", "u", "e", "y", "i", "n", "g"]
访问方法：
访问方法不会改变原数组，一般都是返回一个新数组
1. arr1.concat(arr2)
合并arr1和arr2
var arr1 = ["x", "u", "e"]
var arr2 = ["y", "i", "n", "g"]
arr1.concat(arr2) // ["x", "u", "e", "y", "i", "n", "g"]
2. arr.includes(searchElement, fromIndex)
从fromIndex开始查找searchElement，找到了返回true，找不到返回false
fromIndex可省略，默认从下标0开始找。
arr.includes('u') // true
arr.includes('u', 2) // false
3. arr.join(separator)
数组合并成一个字符串，每一个元素用separator隔开。
separator可省略，默认为,
arr.join() // "x,u,e,y,i,n,g"
arr.join('') // "xueying"
4. arr.slice(begin, end)
抽取数组在[begin,end)区间内的元素，返回一个新数组。
arr.slice(0, 3) // ["x", "u", "e"]
5. arr.toString()
arr.toString() // "x,u,e,y,i,n,g"
6. arr.indexOf(searchElement[, fromIndex = 0])
返回searchElement的下标，没有则返回 -1
可以指定fromIndex表示从哪个下标开始查找，默认为下标0
arr.indexOf('u') // 1
arr.indexOf('u', 2) // -1
7. arr.lastIndexOf(searchElement[, fromIndex = arr.length – 1])
找到数组中最后一个和searchElement相等的元素的下标。
可以指定fromIndex表示从哪个下标开始查找，默认从数组最后一个元素开始。
var arr = ["x", "u", "l", "e", "y", "i", "n", "g", "l"]
arr.lastIndexOf('l') // 8
迭代方法
1. arr.forEach()
语法：
array.forEach(callback(currentValue, index, array){
//do something
}, thisArg)
对数组每一个元素执行callback函数。
callback函数接收3个参数：
-
currentValue：当前元素的值 -
index： 当前元素的下标 -
array：原数组
thisArg：可选，用作callback函数的this值。
var arr = ['x', 'u', 'e', 'y', 'i', 'n', 'g']
arr.forEach((element, index, array) => console.log('arr[' + index + '] = ' + element))
/*
arr[0] = x
arr[1] = u
arr[2] = e
arr[3] = y
arr[4] = i
arr[5] = n
arr[6] = g
*/
2. arr.every(callback[, thisArg]) && arr.some(callback[, thisArg])
arr.every(callback[, thisArg])
测试数组的 所有 元素是否都通过了callback函数的测试。
全部通过返回true ，否则返回false
thisArg指定this值。
// 格式和forEach方法没区别
var arr = ['x', 'u', 'e', 'y', 'i', 'n', 'g']
console.log(arr.every((element, index, array) => element === element.toLowerCase())) // 数组中的元素是否都为小写
// true
arr.some(callback[, thisArg])
测试数组的 某些 元素是否全部通过了callback函数的测试。
// 语法和forEach方法没区别
var arr = ['X', 'u', 'e', 'y', 'i', 'n', 'g'] // 第一个元素大写
console.log(arr.some((element, index, array) => element === element.toLowerCase())) // 数组中是否有小写的元素
// true
3. arr.filter(callback[, thisArg])
过滤器，创建一个新数组, 其包含通过所提供函数实现的测试的所有元素
语法还是跟forEach方法没区别。
var arr = ['X', 'u', 'e', 'y', 'i', 'n', 'g'] // 第一个元素大写
console.log(arr.filter((element, index, array) => element === element.toLowerCase()))
// [ 'u', 'e', 'y', 'i', 'n', 'g' ]
4. arr.find(callback[, thisArg]) && arr.findIndex(callback[, thisArg])
arr.find(callback[, thisArg])
语法同上。
返回数组中第一个满足callback函数的元素的值。否则返回 undefined。
var arr = ['X', 'u', 'e', 'y', 'i', 'n', 'g'] // 第一个元素大写
console.log(arr.find((element, index, array) => element === element.toLowerCase()))
// "u"
arr.findIndex(callback[, thisArg])
语法同上。
返回数组中第一个满足callback函数的元素的索引。否则返回-1。
var arr = ['X', 'u', 'e', 'y', 'i', 'n', 'g'] // 第一个元素大写
console.log(arr.findIndex((element, index, array) => element === element.toLowerCase()))
// 1
5. arr.entries()
(迭代器）返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。
跟Python中迭代器一样，用.next()访问下一键值对。
var iterator = arr.entries();
iterator.next() // {value: Array(2), done: false} done表示迭代是否已经完成
iterator.next().value // [1, "u"]
6. arr.keys() && arr.values()
arr.keys()
返回一个新的Array迭代器，它包含数组中每个索引的键。
var iterator = arr.keys();
iterator.next() // {value: 0, done: false}
iterator.next().value // 1
// 不断next直到最后一个
console.log(iterator.next()) // {value: undefined, done: true}
arr.values()
返回一个新的 Array Iterator 对象，它包含数组每个索引的值。
PS: Chrome 未实现，Firefox未实现，Edge已实现。
Chrome 及Firefox可以用”arrSymbol.iterator“方法来代替values()方法。
var arr = [1,2,3,4,5]
var i = arr[Symbol.iterator]()
i.next() // {value: 1, done: false}
i.next() // {value: 2, done: false}
7. arr.map(callback)
创建一个新数组，其结果是该数组中的每个元素都调用callback函数后返回的结果。
语法：
arr.map(function callback(currentValue, index, array) {
// Return element for new_array
}[, thisArg])
例子：
arr.map((element, index, array) => element.toUpperCase()) // ["X", "U", "E", "Y", "I", "N", "G"]
8. arr.reduce(callback[, initialValue])
累加器, 数组中的每个元素（从左到右）应用一个函数，将其减少为单个值。
callback函数接收4个参数：
-
accumulator：累加器累加回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue -
currentValue：数组中正在处理的元素 -
currentIndex：数组中正在处理的当前元素的索引。 -
array：原数组
initialValue：用作第一个调用 callback的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。
回调函数第一次执行时，accumulator 和currentValue的取值有两种情况：
- 调用reduce时提供initialValue，accumulator取值为initialValue，currentValue取数组中的第一个值。
- 没有提供 initialValue，accumulator取数组中的第一个值，currentValue取数组中的第二个值。
// 取最大值
var arr = [1, 2, 3, 4, 5, 6]
console.log(arr.reduce((accumulator, currentValue) => Math.max(accumulator, currentValue)))
// 6
// 连接数组的元素
var arr = ['x', 'u', 'e', 'y', 'i', 'n', 'g']
console.log(arr.reduce((accumulator, currentValue) => accumulator.concat(currentValue)))
// xueying
