数组的各种方法

会改变自身的方法

• array.pop()
  删除一个数组中的最后一个元素，并且返回这个元素

• array.push(element1, ...elementN)
  添加一个或多个元素到数组的末尾，并返回数组新的长度

• array.reverse()
  前后颠倒数组中元素的位置，第一个元素会成为最后一个

• array.shift()
  删除数组的第一个元素，并返回这个元素

• array.unshift(element1, ...elementN)
  在数组的开头插入一个或多个元素，并返回数组的新长度

• array.sort([function(a, b)])
  对数组的元素做原地的排序，并返回这个数组，按升序排列的。sort默认把元素转成字符串后按照字符串的unicode码位点排序，所以很多时候排序结果不是我们所期望的。但是我们可以自己传一个函数作为参数，手动排序

如果指明了`compareFunction`，那么数组会按照调用该函数的返回值进行排序。比较函数`compareFunction`接收两个参数`a`和`b`，`a`和`b`是两个将要被比较的元素：

*   **`compareFunction(a,b)`返回的值小于`0`**：那么`a`就小于`b`，也就是说`a`排在了`b`的前面
*   **`compareFunction(a,b)`返回的值大于`0`**: 那么`a`就大于`b`，也就是说`a`排在了`b`的后面
*   **`compareFunction(a,b)`返回的值等于`0`**：那么`a`就等于`b`，也就是说`a`和`b`的位置保持不变

不仅可以升序降序还可以随机排序

var randomArray = [9,0,23,8,3,5]; 
function randomSort(a, b){ 
  return Math.random() - 0.5; 
} 
console.log(randomArray.sort(randomSort));

数组的sort()

• array.splice(start, deleteCount[, item1[, item2...])
  在任意的位置给数组添加或删除任意个元素（拼接），返回被删除的元素组成的数组，没有则返回空数组

• array.copyWithin(target, start = 0, end = this.length)
  在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。
  target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
  start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数。
  end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数。

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

上面代码表示将从 3 号位直到数组结束的成员（4 和 5），复制到从 0 号位开始的位置，结果覆盖了原来的 1 和 2。

// 将3号位复制到0号位
[1, 2, 3, 4, 5].copyWithin(0, 3, 4)
// [4, 2, 3, 4, 5]

// -2相当于3号位，-1相当于4号位
[1, 2, 3, 4, 5].copyWithin(0, -2, -1)
// [4, 2, 3, 4, 5]

不会改变自身的方法

• array.concat(value1, value2.....)
  将传入的数组或非数组值与原数组合并，组成一个新的数组并返回。假设value1中如果有对象的话，新返回的数组中的对象和value1中是同一个引用。

• array.join([separator = ','])
  将数组中的所有元素连接成一个字符串(默认用逗号作为分隔符，如果separator是一个空字符串，那么数组中的所有元素将被直接连接)
  如果元素是undefined或者null，则会转化成空字符串

• array.slice([begin = 0 [, end = this.length - 1]])
  把数组中一部分的浅复制（shallow copy）存入一个新的数组对象中，并返回这个新的数组
  不修改原数组，只会返回一个包含了原数组中提取的部分元素的一个新数组

• array.toString()
  返回一个字符串，该字符串由数组中的每个元素的toString（）返回值经调用join（）方法连接（由逗号隔开）组成。

var arr = ['abc', 2, {a: 'test'}]
 console.log(arr.toString())        //'abc,2,[object Object]'

• array.indexOf(searchElement[, fromIndex = 0])
  返回指定元素能在数组中找到的第一个索引值，否则返回-1
  fromIndex可以为负，表示从倒数第n个开始（此时仍然从前向后查询数组）
  使用“严格相等”（===）进行匹配

          var obj = {a: 'test'}
          var arr = ['a', 'b', {a: 'test'}]
          console.log(arr.indexOf(obj))     //-1  因为是严格相等

          var arr2 = [1, 'b', {a: 'test'}]
          console.log(arr2.indexOf('1'))      //-1

• array.lastIndexOf(searchElement[, fromIndex = arr.length - 1])
  返回指定元素在数组中的最后一个的索引，如果不存在则返回-1， 从数组的后面向前查找

遍历方法

• array.forEach((v, i, a) => {})
  让数组的每一项都执行一次给定的函数，ES5中操作数组的一种方法
  v表示当前项的值，i表示当前索引，a表示数组本身
  forEach遍历的范围在第一次调用 callback前就会确定。调用forEach后添加到数组中的项不会被 callback访问到。如果已经存在的值被改变，则传递给 callback的值是 forEach遍历到他们那一刻的值。已删除的项不会被遍历到。

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

for (let index of ['a', 'b'].keys()) {
  console.log(index);
}
// 0
// 1

for (let elem of ['a', 'b'].values()) {
  console.log(elem);
}
// 'a'
// 'b'

for (let [index, elem] of ['a', 'b'].entries()) {
  console.log(index, elem);
}
// 0 "a"
// 1 "b"

如果不使用for...of循环，可以手动调用遍历器对象的next方法，进行遍历。

let letter = ['a', 'b', 'c'];
let entries = letter.entries();
console.log(entries.next().value); // [0, 'a']
console.log(entries.next().value); // [1, 'b']
console.log(entries.next().value); // [2, 'c']

• array.every(callback(v, i, a){})
  callback只会为那些已经被赋值的索引调用，不会为那些被删除或从来没有被赋值的索引调用
  和forEach函数类似
  注意：array.every()返回一个布尔值，即对每个元素的callback函数结果作逻辑“&”操作

• array.some()
  使用方法同上，
  注意：对每个元素的callback函数结果作逻辑“||”操作

• array.filter((v, i, a) => {})
  使用指定的函数测试所有元素，并创建一个包含所有测试通过的元素的新数组
  callback函数返回一个布尔值，true即通过测

• array.find((v, i, a) =>{})
  返回数组中满足测试条件的第一个元素，如果没有满足条件的元素，则返回undefined

[1, 5, 10, 15].find(function(value, index, arr) {
  return value > 9;
}) // 10

• array.findIndex((v, i, a) =>{})
  数组实例的findIndex方法的用法与find方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。

[1, 5, 10, 15].findIndex(function(value, index, arr) {
  return value > 9;
}) // 2

这两个方法都可以接受第二个参数，用来绑定回调函数的this对象。

function f(v){
  return v > this.age;
}
let person = {name: 'John', age: 20};
[10, 12, 26, 15].find(f, person);    // 26

indexOf方法无法识别数组的NaN成员，但是findIndex方法可以借助Object.is方法做到。

[NaN].indexOf(NaN)
// -1

[NaN].findIndex(y => Object.is(NaN, y))

• array.map((v, i, a) => {})
  返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组
  map 不修改调用它的原数组本身（当然可以在 callback 执行时改变原数组）

• array.reduce(callback[, initialValue])
  该方法接收一个函数作为累加器（accumulator），数组中的每个值（从左到右）开始合并，最终为一个值
  callback参数：
  previousValue:上一次调用回调返回的值，或者是提供的初始值（initialValue）
  currentValue: 数组中当前被处理的元素
  index： index
  array： 调用的数组
  如果 initialValue 在调用 reduce 时被提供，那么第一个 previousValue 等于 initialValue ，并且currentValue 等于数组中的第一个值；如果initialValue 未被提供，那么previousValue 等于数组中的第一个值，currentValue等于数组中的第二个值。

[0, 1, 2, 3, 4, 5].reduce((p, v, i , a) => {
  return p + v
})
// 数组扁平化
var flattened = [[0, 1], [2, 3], [4, 5]].reduce((a, b) => {
  return a.concat(b)
})

• array.includes(v,[ fromIndex = 0] )
  返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。该方法的第二个参数表示搜索的起始位置，默认为0。如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为-4，但数组长度为3），则会重置为从0开始。

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

非数组转换为数组

Array.from方法用于将两类对象转为真正的数组
Array.of方法用于将一组值，转换为数组。

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

slice，substring，substr的区别

首先，他们都接收两个参数，slice和substring接收的是起始位置和结束位置(不包括结束位置)，而substr接收的则是起始位置和所要返回的字符串长度。直接看下面例子：

var test = 'hello world';

alert(test.slice(4,7));             //o w
alert(test.substring(4,7));         //o w
alert(test.substr(4,7));            //o world

上面的操作都不会改变test字符串，而是返回新值。
substring是以两个参数中较小一个作为起始位置，较大的参数作为结束位置。

接着，当接收的参数是负数时，slice会将它字符串的长度与对应的负数相加，结果作为参数；substr则仅仅是将第一个参数与字符串长度相加后的结果作为第一个参数；substring则干脆将负参数都直接转换为0。
slice,substr和substring的区别
split分割字符串为数组。但是如果分割的参数字符串中没有，返回值还是个数组，只有一个值为字符串本身。