数组的增删

push()：添加到最后
pop():取出最后一个
shift()：取出第一个
unshift()：添加到第一个

splice() ：

返回删除的数组，如果没有则为空数组,会改变原数组。可进行删除、插入、替换。
splice(0,2)删除前两项。
splice(2,0,”red”,”green”)，从当前数组的位置2开始插入字符串。
splice(2,1,”red”,”green”),删除当前数组位置的第二项，然后从位置2开始插入字符串。

slice() :

slice返回一个新数组，不会影响原数组
slice可以接收1-2个参数，即要返回项的起始和结束位置。如果有两个参数，不会返回结束位置的项。

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

concat():

concat()返回一个新数组，不会影响原数组。简单来说就是数组拼接。

var a = [1,2,3];
var b = a.concat(4,[5,6]);
console.log(a); // 1,2,3
console.log(b); // 1,2,3,4,5,6

数组的变形

join：可以把数组变成字符串，接受参数返回字符串，数组本身不变

split：接受参数，返回字符串以参数分割的数组

toString(),valueOf():返回以逗号分隔的字符串。

数组的迭代

每个方法都接收两个参数，传入这些方法中的函数会接收3个参数，数组项的值、该项在数组的位置、数组对象本身。

• every
• some
• filter
• foreach:
• map:

every、some用户查询数组中的项是否满足某个条件。

var numbers = [1,2,32,32,1,2,3,5,2,1,8,5,9];
var everyResult = numbers.every(function(item,index,array){
    return (item > 2)
})
console.log(everyResult) // false

var numbers = [1,2,32,32,1,2,3,5,2,1,8,5,9];
var someResult = numbers.some(function(item,index,array){
    return (item > 2)
})
console.log(someResult) // true

filter:用指定条件过滤数组

var numbers = [1,2,32,32,1,2,3,5,2,1,8,5,9];
var filterResult = numbers.filter(function(item,index,array){
    return (item > 2)
})
console.log(filterResult) // [32, 32, 3, 5, 8, 5, 9]

map:返回指定条件的数组

var numbers = [1,2,32,32,1,2,3,5,2,1,8,5,9];
var mapResult = numbers.map(function(item,index,array){
    return item*2;
})
console.log(mapResult) // [2, 4, 64, 64, 2, 4, 6, 10, 4, 2, 16, 10, 18]

forEach:对数组中的每一项运行传入的函数

var numbers = [1,2,32,32,1,2,3,5,2,1,8,5,9];
numbers.forEach(function(item,index,array){
    // 执行操作
})

数组的归并

reduce、reduceRight。两个方法都会迭代数组的所有项，然后构建一个最终返回的值。

函数接收4个参数，前一个值、当前值、项的索引和数组对象。

var values = [1,2,3,4,5];
var sum = values.reduce(function(pre,cur,index,valuse){
    return pre+cur;
})
console.log(sum)

数组的排序

reverse()、sort()

reverse()不接受参数，反转数组的顺序。
sort默认按升序排列数组，接收一个比较函数。如果第一个数位于第二个数之前则返回一个负数。

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

function compare(val1,val2){
 return val1 - val2;
}

ES6中新增数组的拓展

Array.from()

Array.from方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括ES6新增的数据结构Set和Map）。任何有length属性的对象，都可以通过Array.from方法转为数组，而此时扩展运算符就无法转换。

Array.from还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组。

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};

// ES5的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']

// ES6的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

Array.of()

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

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

copyWithin()

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

它接受三个参数。

target（必需）：从该位置开始替换数据。
start（可选）：从该位置开始读取数据，默认为0。如果为负值，表示倒数。
end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数。

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

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

find()和findIndex()

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

[1, 4, -5, 10].find((n) => n < 0)
// -5

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

fill()

fill方法使用给定值，填充一个数组。fill方法还可以接受第二个和第三个参数，用于指定填充的起始位置和结束位置。

['a', 'b', 'c'].fill(7)
// [7, 7, 7]

new Array(3).fill(7)
// [7, 7, 7]

['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']

entries()，keys()和values()

ES6提供三个新的方法——entries()，keys()和values()——用于遍历数组。它们都返回一个遍历器对象（详见《Iterator》一章），可以用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"

includes()

Array.prototype.includes方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。该方法属于ES7，但Babel转码器已经支持。

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