javascript的Array.prototype对象的所有方法

length

表示数组的长度

var  arr=[22,33,44];
console.log(arr.length);//3

toString

将数组转化为字符串，不改变原数组。

var arr=[1,2,3,4];
console.log(arr.toString());//"1,2,3,4"

join

将数组插入字符串，生成字符串。

var arr=[1,2,3,4];
arr.join();//"1,2,3,4" 直接数组生成对应的字符串
arr.join('');//"1234"插入空字符串，生成字符串

pop

从数组的末位剔除一个元素（改变原数组）

var  arr=[1,2,3,4];
var temp=arr.pop();
console.log(temp);//4
console.lgo(arr);//[1,2,3]

push

跟pop相反，向数组末位插入元素。(可以插入多个)

var arr=[1,2,3,4];
arr.push(5,6,7);//返回的是插入元素后的数组长度 6
console.log(arr);//[1,2,3,4,5,6,7]

reverse

颠倒数组的顺序（改变原数组）

var arr=[1,2,3,4];
arr.reverse();
console.log(arr);//[4,3,2,1]

shift

与pop相反，从数组首位截取数组。

var  arr=[1,2,3,4];
var temp=arr.shift();
console.log(1);//返回的是截取的元素
console.log(arr);//[1,2,3]

unshift

跟push类似，从数组的首位插入，可插入多个值。（改变原数组）

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

slice

截取数组，参数为开始索引（结束索引）,当不传参数时，会截取整个数组，当只有一个参数时，该参数为开始的索引到数组结束。当为两个参数时,不包括结束索引的元素。参数可以为负数，表示逆序。不改变原数组。

var arr=[1,2,3,4,5];
arr.slice();//[1,2,3,4,5]
arr.slice(1);//[2,3,4,5]
arr.slice(1,2);//[2]

splice

插入元素到数组中，第一个参数为开始插入数组的索引值，第二个要截取元素的个数，后面为要插入的元素，改变原数组。返回的为截取元素组成的数组。

var  arr=[1,2,3,4,5];
arr.splice(1,2,1);//[2,3]
console.log(arr);//[1,1,4,5]

sort

sort默认的时候根据Unicode排序，当指点回调函数后，根据函数排序，改变原数组。当行数callback(a,b)的返回值小于零时，a就在b前面。改变数组。

var arr=[1111,22,333];
arr.sort();//[1111,22,333]
arr.sort(function(a,b){
      return a-b;
})//[22,333,1111]

filter

对数组进行过滤，遍历数组，依次将返回值为true的元素放在一个新的数组中，不改变原数组。回调函数的三个形参分别表示当前元素，当前元素的索引，数组。不会改变原数组。

var arr=[1,2,3,4,5,6];
arr.filter(function(item,index,target){
      return item>2
})//[3,4,5,6]
console.log(arr);//[1,2,3,4,5,6]

forEach

遍历数组，依次操作元素。回调函数的参数与filter一样。不改变原数组，简洁了对数组的遍历。

var arr=[1,2,3,4,5,6],
     temp=[];
arr.forEach(function(item,index,target){
    temp.push(item);
})
console.log(temp);//[1,2,3,4,5,6]
console.log(arr);//[1,2,3,4,5,6]

some

判断数组中是否有元素满足条件，有元素满足条件，则返回true,否则返回false。回调函数的参数同上。

var arr=[1,2,3,4];
arr.some(function(item,index.target){
    return item>3
});//true
arr.some(function(item,index,target){
    return item>8
});//false

every

判断数组中是否所有的元素都满足条件。全满足时，返回true，否则返回false。

var arr=[1,2,3,4];
arr.some(function(item,index.target){
    return item>0
});//true
arr.some(function(item,index,target){
    return item>8
});//false

map

对应原数组生成对应的新数组，回调函数里面的形参同上。不改变原数组。

var arr=[1,2,3,4,5];
arr.map(function(item,index,target){
   return item+1
})//[2,3,4,5,6]
console.log(arr);//[1,2,3,4,5]

indexOf

两个参数，第一个参数为要查询的元素，第二参数为查询的起始起始位子（包含该索引的元素），从数组的首位开始查，只返回第一次查询到的索引。

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

lastIndexOf

与indexOf的效果相反，从数组的末位开始查，只返回第一次查询到的索引值。

var arr=[1,2,3,4,2,3,4];
arr.lastIndexOf(4);//6
arr.lastIndexOf(4,-2);//3

reduce(callback(prev,next,index,target),first);

该参数有两个参数，第二个为可选参数。第一个为回调函数，第一个第一次为第一个元素（假如第二参宿为空），运行一次后，第一次为运行一次的返回值，第二个参数为下个索引的值，第三个位第二个值的索引，第三个为原数组。

//数组去重
var arr=[1,2,3,4,2,2,3];
arr.reduce(function(prev,next,index,target){
       prev[next]=(prev[next]+1)||1;
       return prev;
},{})//{1:1,2:3,3:2,4:1}

reduceRight

跟reduce的用法一样，不过从右边开始。

 copyWithin

copyWithin(target,start,end)，第一个参数为插入值的起点索引（包含），后两个为可选参数，原数组的length不变，start为复制的起始索引（包含），end为结束索引（不包含）。

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

//当后两个参数为空时，会从起始位置开始复制。
var arr=[0,1,2,3,4,5,6];
arr.copyWithin(3);//[0,1,2,0,1,2,3]

find

两个参数，第一个为回调函数，第二个为可选参数，表示回调函数中this的指向，假如没有的话，this指向为undefined,找到第一个符合条件的元素并返回。

var arr=[1,2,3,4,5];
arr.find(function(item,index,target){
    return item>this
},3);//4

findIndex

跟find用法一样，不过返回的是索引值，而不是元素的值

var arr=[1,2,3,1,4,5];
arr.findIndex(function(item,index,target){
    return item<this
},3);//0

fill

三个参数，后两个参数为可选参数。fill(value,start,end) [start,end) 包含填充的起始位置，不包含结束位子。该方法会改变原数组。

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

includes

两个参数，第二个为可选参数。includes(value,start) 判断是否包含某元素。start为起始位子。

var arr=[1,2,3,4,5];
arr.includes(3,3);//false
arr.includes(3);//true

entries

生个一个迭代器。

var arr=['lili','kangkang'];
var temp=arr.entries();
console.log(temp.next().value);//[0,'lili']
console.log(temp.next().value);//[1,'kangkang']

keys

生成一个迭代器，值为索引值。

var arr=['lili','kangkang'];
var temp=arr.keys();
console.log(temp.next())// {value: 0, done: false}
console.log(temp.next())// {value: 1, done: false}
console.log(temp.next())// {value: undefined, done: true}

concat

合并数组，生成一个新的数组，不会改变原数组。参数可以为数组，也可以为元素。

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

values

跟keys用法一样，不过返回的value不是索引值，而是元素。

var arr=['lili','kangkang'];
var temp=arr.values();
console.log(temp.next())// {value: 'lili', done: false}
console.log(temp.next())// {value: 'kangkang', done: false}
console.log(temp.next())// {value: undefined, done: true}