数组方法总结

总结常用javascript数组方法

Array 对象
数组创建
设置和读取数组元素
数组方法

concat()
join()
pop()
push()
reverse()
shift()
unshift()
slice()
splice()
sort()
toString()
valueOf()
indexOf()
lastIndexOf()
forEach()
map()
filter()
every()
some()
reduce()
reduceRight()
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()

 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.reverse());//(4) [“d”, “c”, “b”, “A”]
console.log(arr);(8) //(4) [“d”, “c”, “b”, “A”]

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()方法不会改变原数组，返回值为选定的一个新的元素数组。

 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)

 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类似）从数组的最后一项开始，向前逐个遍历到第一位，迭代数组的所有项，然后构建一个最终返回的值。