JS数组的方法

keys() —ES6规范

数组的 keys() 方法返回一个数组索引的迭代器。

//索引迭代器会包含那些没有对应元素的索引
var arr = ["a", , "c"];
var sparseKeys = Object.keys(arr);

//ES6语法
var denseKeys = [...arr.keys()];
console.log(sparseKeys); // [0, 2]
console.log(denseKeys);  // [0, 1, 2]

entries() —ES6规范

方法返回一个数组迭代器对象，该对象包含数组中每一个索引的键值对。

var arr = ["a", "b", "c"];
var eArr = arr.entries();
eArr.next().value;//[0,'a']
eArr.next().value;//[1,'b']
eArr.next().value;//[2,'c']
eArr.next().value;//'undefined'

concat()

将传入的数组或非数组值与原数组合并,组成一个新的数组并返回.

（1）连接多个数组

var arr1 = [1,2,3];
var arr2 = [4,5,6];
var arr3 = [7,8,9];
arr1.concat(arr2,arr3);//[1,2,3,4,5,6,7,8,9]

（2） 将非数组值合并到数组里

var arr1 = [1,2,3];
arr1.concat(4,[5,6]);//[1,2,3,4,5,6]

copyWithin(target,start,end)

会浅拷贝数组的部分元素到同一数组的不同位置，且不改变数组的大小，返回该数组。

参数：
（1）target：0 为基底的索引，复制序列到该位置。如果是负数，target 将从末尾开始计算。
如果 target 大于等于 arr.length，将会不发生拷贝。如果 target 在 start 之后，复制的序列将被修改以符合 arr.length。
（2）start：0 为基底的索引，开始复制元素的起始位置(包括该位置)。如果是负数，start 将从末尾开始计算。
如果 start 被忽略，copyWithin 将会从0开始复制。
（3）end：0 为基底的索引，开始复制元素的结束位置。copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素。如果是负数， end 将从末尾开始计算。
如果 end 被忽略，copyWithin 将会复制到 arr.length。

var arr = [1,2,3,4,5]
//省略start，默认从0开始复制；target是负数，所以从末尾开始计算，往前推两个位置
arr.copyWithin(-2);//[1,2,3,1,2]
//从数组的index=2处开始拷贝，省略end，默认拷贝到最后一个元素
arr.copyWithin(0,2);//[3,4,5,4,5]
//从数组的index=1处开始拷贝，拷贝到index=3处但不包括该位置的元素
arr.copyWithin(0,1,3);//[2,3,3,4,5]

fill(value,start,end)

可以将一个数组中指定区间的所有元素的值, 都替换成或者说填充成为某个固定的值。

参数：
（1）value：用来填充数组元素的值，具体要填充的元素区间是 [start, end) , 一个半开半闭区间.

（2）start：可选，开始索引。默认值0

（3）end：可选，结束索引。默认值this.length

var arr = [1,2,3];
arr.fill(4);//[4,4,4]
arr.fill(4,2);//[1,2,4]
arr.fill(4,0,2);//[4,4,4]

every()

方法测试数组的所有元素是否都通过了指定函数的测试，直有所有项都返回true则该方法返回true

//检测数组中的所有元素是否都大于10
[12,23,565,74,2].every(function(element,index,array){
    return element > 10
})//false

some()

方法测试数组中的某些元素是否通过了指定函数的测试.只要数组中有一项返回true，则该方法返回true

function isBigEnough(element, index, array) {
      return (element >= 10);
}
var passed = [2, 5, 8, 1, 4].some(isBigEnough);//false

filter()

方法使用指定的函数测试所有元素，并创建一个包含所有通过测试的元素的新数组。

//返回数组中所有包含'a'的元素
var arr = ['linda','lisa','tom','lee'];
arr.filter(function(element,index,array){
    return /a/.test(element);
})//['linda','lisa']

map()

方法返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组。

//求数组中每个元素的平方根
[1,4,9].map(Math.sqrt)//[1,2,3]
//在一个 String上使用 map 方法获取字符串中每个字符所对应的 ASCII 码组成的数组
Array.prototype.map.call('hello world',function(element){
    return element.charCodeAt(0)
})
//[104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]

slice(start,end)

方法会浅复制（shallow copy）数组的一部分到一个新的数组，并返回这个新数组。

//基本用法
[1,2,3,4,5].slice(2);//[3,4,5]
//slice 方法可以用来将一个类数组（Array-like）对象/集合转换成一个数组
function test(){
    return Array.prototype.slice.call(arguments)
}
test(1,2,3);//[1,2,3]

splice(start, deleteCount,itemN)

方法用新元素替换旧元素，以此修改数组的内容。

参数：
（1）start：从数组的哪一位开始修改内容。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位
（2）deleteCount：整数，表示要移除的数组元素的个数。如果 deleteCount 是 0，则不移除元素。这种情况下，至少应添加一个新元素。如果 deleteCount 大于start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）
（3）itemN：要添加进数组的元素。如果不指定，则 splice() 只删除数组元素。

var myFish = ["angel", "clown", "mandarin", "surgeon"];

//从第 2 位开始删除 0 个元素，插入 "drum"
var removed = myFish.splice(2, 0, "drum");
//运算后的 myFish:["angel", "clown", "drum", "mandarin", "surgeon"]
//被删除元素数组：[]，没有元素被删除

//从第 3 位开始删除 1 个元素
removed = myFish.splice(3, 1);
//运算后的myFish：["angel", "clown", "drum", "surgeon"]
//被删除元素数组：["mandarin"]

//从第 2 位开始删除 1 个元素，然后插入 "trumpet"
removed = myFish.splice(2, 1, "trumpet");
//运算后的myFish: ["angel", "clown", "trumpet", "surgeon"]
//被删除元素数组：["drum"]

//从第 0 位开始删除 2 个元素，然后插入 "parrot", "anemone" 和 "blue"
removed = myFish.splice(0, 2, "parrot", "anemone", "blue");
//运算后的myFish：["parrot", "anemone", "blue", "trumpet", "surgeon"]
//被删除元素的数组：["angel", "clown"]

//从第 3 位开始删除 2 个元素
removed = myFish.splice(3, Number.MAX_VALUE);
//运算后的myFish: ["parrot", "anemone", "blue"]
//被删除元素的数组：["trumpet", "surgeon"]