常用js数组方法

Array 对象

Array 对象用于在单个的变量中存储多个值。

数组创建

首先介绍一下数组的创建方法，有两种方式：
字面量方式：

	var arr1 = [];//创建一个空数组
    var arr2 = [11];//创建一个只有一个元素的数组，主要用于与构造函数做比较
    var arr3 = [1,2,3,4];//创建有四个元素的方法

构造函数方式：

	var arr1 = new Array();//创建一个空数组
    var arr2 = new Array(10);//创建长度位10的数组
    var arr3 = new Array(10,10,11,123,1124);//创建一个包含5个元素的数组

设置和读取数组元素

	 var arr = [1,2,3,4];
     console.log(arr[0]);//使用索引可获取每个元素的值
     arr[0] = 5;//可直接更改某个元素的值
     console.log(arr.length);//length可获取数组的长度

数组方法

方法	对应版本	描述	是否改变原数组
concat()	ES5-	合并数组，并返回合并之后的数据	N
join()	ES5-	使用分隔符，将数组转为字符串并返回	N
pop()	ES5-	删除最后一位，并返回删除的数据	Y
shift()	ES5-	删除第一位，并返回删除的数据	Y
unshift()	ES5-	在第一位新增一或多个数据，返回长度	Y
push()	ES5-	在最后一位新增一或多个数据，返回长度	Y
reverse()	ES5-	反转数组，返回结果	Y
slice()	ES5-	截取指定位置的数组，并返回据	N
sort()	ES5-	排序（字符规则），返回结果	Y
splice()	ES5-	删除指定位置，并替换，返回删除的数据	Y
toString()	ES5-	直接转为字符串，并返回	N
valueOf()	ES5-	返回数组对象的原始值	N
indexOf()	ES5	查询并返回数据的索引	N
lastIndexOf()	ES5	反向查询并返回数据的索引	N
forEach()	ES5	参数为回调函数，会遍历数组所有的项，回调函数接受三个参数，分别为value，index，self；forEach没有返回值	N
map()	ES5	同forEach，同时回调函数返回数据，组成新数组由map返回	N
filter()	ES5	同forEach，同时回调函数返回布尔值，为true的数据组成新数组由filter返回	N
every()	ES5	同forEach，同时回调函数返回布尔值，全部为true，由every返回true	N
some()	ES5	同forEach，同时回调函数返回布尔值，只要由一个为true，由some返回true	N
reduce()	ES5	归并，同forEach，迭代数组的所有项，并构建一个最终值，由reduce返回	N
reduceRight()	ES5	反向归并，同forEach，迭代数组的所有项，并构建一个最终值，由reduceRight返回	N

concat()

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

注释后为输出结果，由以上整理可以得出concat()方法不会该改变原数组，返回值为一个新数组。需要注意的是a.concat(1,[1,2,3],2),并不会把[1,2,3],当成一个数组连接。

join()

	var arr = ["A","b","c","d"];
    console.log(arr.join());//A,b,c,d
    console.log(arr.join("$"));//A$b$c$d
    console.log(arr);//(4) ["A", "b", "c", "d"]

join()方法不会改变原数组，返回值为一个由参数拼接的字符串；当里面的参数为空时，默认使用逗号分隔，有参数时使用参数分隔。

pop()

	var arr = ["A","b","c","d"];
    console.log(arr.pop());//d
    console.log(arr.pop());//c
    console.log(arr);//(2) ["A", "b"]

pop()方法会改变原数组，它的返回值为被删除的元素。

push()

    var arr = ["A","b","c","d"];
    console.log(arr.push("e"));//5
    console.log(arr.push("g","h","i"));//8
    console.log(arr);(8) //["A", "b", "c", "d", "e", "g", "h", "i"]

push()方法会改变原数组，返回值为添加后的数组长度。

reverse()

    var arr = ["A","b","c","d"];
    console.log(arr.reverse());//(4) ["d", "c", "b", "A"]
    console.log(arr) //(4) ["d", "c", "b", "A"]

reverse()方法会改变原数组，返回值为原数组。

shift()

    var arr = ["A","b","c","d"];
    console.log(arr.shift());// "A"
    console.log(arr); //(3) ["b","c","d"]

shift()方法会改变原数组，返回值为被删除的值。

unshift()

    var arr = ["A","b","c","d"];
    console.log(arr.unshift());//4
    console.log(arr.unshift("e",2));//6
    console.log(arr);(8) //(6) ["e", 2, "A", "b", "c", "d"]

unshift()方法会改变原数组，返回值为删除后数组的长度。

slice()

语法：arrayObject.slice(start,end)

参数	描述
start	必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
end	可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。

    var arr = ["A","b","c","d"];
    console.log(arr.slice(0));//(4) ["A", "b", "c", "d"]
    console.log(arr.slice(2,4));//(2) ["c", "d"]
    console.log(arr.slice(-3,2));//["b"]
    console.log(arr); //(4) ["A", "b", "c", "d"]

slice()方法不会改变原数组，返回值为选定的一个新的元素数组。

splice()

arrayObject.splice(index,howmany,item1,…,itemX)

参数	描述
index	必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany	必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, …, itemX	可选。向数组添加的新项目。

    var arr = ["A","b","c","d"];
    console.log(arr.splice(0,1));//["A"] 删除 返回被删除的元素
    console.log(arr); //(3) ["b", "c", "d"]
    console.log(arr.splice(0,0,"e","f"));//[] 添加 ,未删除元素，所以返回一个空数组   前两个参数一样可以指定添加位置 
    console.log(arr); //(5) ["e", "f", "b", "c", "d"]
    console.log(arr.splice(0,2,"x"));//(2) ["e", "f"] 替换 返回被替换的元素
    console.log(arr); //(4) ["x", "b", "c", "d"]

splice()方法会改变原数组，返回值参考上方代码。

sort()

var arr = [22,14,120,89,5,7];
    console.log(arr.sort());//(6) [120, 14, 22, 5, 7, 89]
    var arr1 = arr.sort(function(a,b){
        return a-b;
    });
    console.log(arr1);//(6) [5, 7, 14, 22, 89, 120]
    
    var arr2 = arr.sort(function(a,b){
        return b -a;
    });
    console.log(arr2);//(6) [120, 89, 22, 14, 7, 5]

不填写参数，默认以字符串进行比较，可通过使用回调函数进行数值比较。
sort()会改变原数组，返回值为排序后的数组

toString()

	var arr = ["A","b","c","d"];
    console.log(arr.toString());//A,b,c,d
    console.log(arr);//(4) ["A", "b", "c", "d"]

toString()不会改变原数组，返回值以逗号分隔的字符串

valueOf()

	var arr = ["A","b","c","d"];
    console.log(arr.valueOf("b"));//A,b,c,d
    console.log(arr);//(4) ["A", "b", "c", "d"]
    console.log(arr === arr.valueOf()); //true

valueOf()返回数组本身

indexOf()

	var arr = ["A","b","c","d"];
    console.log(arr.indexOf("c"));//2
    console.log(arr.indexOf("e"));//-1
    console.log(arr);//(4) ["A", "b", "c", "d"]

indexOf()不会改变原数组，会在数组中查找输入的参数是否存在，如果存在，则返回该元素的索引，遇到第一个符合条件的就返回，如果不存在，则返回-1；

lastIndexOf()

	var arr = ["h","e","l","l","o"];
    console.log(arr.lastIndexOf("l"));        //3
    console.log(arr.lastIndexOf("l",3));      //3
    console.log(arr.lastIndexOf("l",1));      //-1
    console.log(arr.lastIndexOf("l",-3));     //2
    console.log(arr.lastIndexOf("l",-4));     //-1

与indexof()类似，是从后往前查找

forEach()

var arr = [1, 2, 3, 4, 5];
arr.forEach(function(i, index,a){
console.log(i+ ',' + index + ',' + (a ===arr));
});
//1,0,true
//2,1,true
//3,2,true
//4,3,true
//5,4,true

对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。参数都是function类型，默认有传参，参数分别为：遍历的数组内容；第对应的数组索引，数组本身。

map()

//同forEach
var arr = ["Tom","Jack","Lucy","Lily","May"];
    var a = arr.map(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr === self))
    })
    // 打印结果为：
    // Tom--0--true
    // Jack--1--true
    // Lucy--2--true
    // Lily--3--true
    // May--4--true

    //每次回调函数的返回值被map组成新数组返回
    var arr = ["Tom","Jack","Lucy","Lily","May"];
    var a = arr.map(function(value,index,self){
        return "hi:"+value;
    })
    console.log(a);     //["hi:Tom", "hi:Jack", "hi:Lucy", "hi:Lily", "hi:May"]
    console.log(arr);   //["Tom", "Jack", "Lucy", "Lily", "May"]---原数组未改变

同forEach功能；map的回调函数会将执行结果返回，最后map将所有回调函数的返回值组成新数组返回。

filter()

//同forEach
    var arr = ["Tom","Jack","Lucy","Lily","May"];
    var a = arr.filter(function(value,index,self){
        console.log(value + "--" + index + "--" + (arr === self))
    })
    // 打印结果为：
    // Tom--0--true
    // Jack--1--true
    // Lucy--2--true
    // Lily--3--true
    // May--4--true

    //当回调函数的返回值为true时，本次的数组值返回给filter，被filter组成新数组返回
    var arr = ["Tom","Jack","Lucy","Lily","May"];
    var a = arr.filter(function(value,index,self){
        return value.length > 3;
    })
    console.log(a);         //["Jack", "Lucy", "Lily"]
    console.log(arr);       //["Tom", "Jack", "Lucy", "Lily", "May"]---原数组未改变

同forEach功能；filter的回调函数需要返回布尔值，当为true时，将本次数组的数据返回给filter，最后filter将所有回调函数的返回值组成新数组返回（此功能可理解为“过滤”）。。

every()

var arr = [1, 2, 3, 4, 5];
    var arr2 = arr.every(function (x) {
        return x < 10;
    });
    console.log(arr2);//true
    var arr3 = arr.every(function (x) {
        return x < 3;
    });
    console.log(arr3);// false

判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true。

some()

        var arr = [1, 2, 3, 4, 5];
        var arr2 = arr.some(function (x) {
            return x < 3;
        });
        console.log(arr2);//true
        var arr3 = arr.some(function (x) {
            return x < 1;
        });
        console.log(arr3);// false

判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。

reduce()

             var values = [1, 2, 3, 4, 5];
            var sum = values.reduce(function (prev, cur, index, array) {
                return prev + cur;
            }, 10);
            console.log(sum);//25

从数组的第一项开始，逐个遍历到最后，迭代数组的所有项，然后构建一个最终返回的值。

reduceRight()

（与reduce类似）从数组的最后一项开始，向前逐个遍历到第一位，迭代数组的所有项，然后构建一个最终返回的值。