Array方法总结

一、不影响原数组产生一个新数组

　　slice:切片->返回新数组->复制数组:arr.slice(0)
　　 arrayObject.slice(start,end): 切片   

var arr= [1,2,3,4]
arr.slice(1,3);//[2, 3]
arr.slice(0);//[1, 2, 3, 4]复制数组，或者循环元素进行复制。复制数组是副本，b===a为false。b=a是指针，b===a为true

 concat: 连接两个或更多的数组->返回新数组->复制数组:arr.concat()

concat() 连接两个或更多的数组，并返回结果。

arrayObject.concat(arrayX,arrayX,......,arrayX)

var arr=[1,2];
arr.concat(3);//[1, 2, 3]
arr.concat([3,4]);//[1, 2, 3, 4],把数组中的元素拿了出来
arr.concat([[6,7],[8,9]]);//[1, 2, Array[2]0: 61: 7length: 2__proto__: Array[0], Array[2]0: 81: 9length: 2__proto__: Array[0]]
//拿出的只是第一层数组中的元素哦

二、影响原数组内部元素顺序

　　reverse:颠倒原数组中元素的顺序(由sort排序实现)->返回改变后的原数组

　　sort:对原数组的元素进行排序->返回改变后的原数组

　　　　

var arr=[1,3,2];
//undefined
arr
//[1, 3, 2]
arr.sort(function(a,b){return b-a})
//[3, 2, 1]
arr.sort(function(a,b){return a-b})//如果得到负数，则第一个参数排在前面
//[1, 2, 3]

Good parts:p79

　　1、它不能正确地给一组数字排序。

　　　　JavaScript的默认比较函数把要被排序的元素都视为字符串。所以你在js里做任何比较要先确定类型哦。

var arr=[16,11,20,4]
//undefined
arr.sort()
//[11, 16, 20, 4]

　　比较函数应该接受两个参数，并且如果这两个参数相等则返回0，如果第1个参数应该排列在前面，则返回一个负数，如果第2个参数应该排列在前端，则返回一个正数。

　　arr.sort(funciton(a,b){return a - b})//1,0,-1都有的哈~

　　这个函数可以使数字正确排序，不能使字符串排序。如果我们想要给任何包含简单值的数组排序，必须要做更多的工作。

2、字符串排序

如果大小写不重要，你的比较函数应该在比较之前先将两个运算数转化为小写。

var m = ['aa','bb','aa','a',8,4,15,16,23,42,8,8,8,8];
        m.sort(function(a,b){
            if(a === b){
                return 0;
            }
            if(typeof a ===  typeof b){
                return a < b ? -1  : 1;//为啥？
            }
            return typeof a < typeof b ? -1 : 1;
        });

　　return 0 ；是一定要写的，否则容易出错。比如 (这一点说明sort方法的不稳定性，即会改变相待值的相对位置。不同浏览器实现不一样。)

var obj1 = { name : "test" };
var obj2 = { name : "test" };
var c = [obj1, obj2];
c.sort(function (a, b) {
    return a.name < b.name ? -1 : 1;
});
//[Object, Object]
c.indexOf(obj1)
//

当然了，比较字符串和数字的话应该不会出现问题。

3、比较对象

 //比较对象
        var by = function(name){
            return function(a,b) {
                if (typeof a === 'object' && typeof b === 'object' && a && b) {//为什么还要判断 &&a&&b.因为null啊！！！typeof null //object
                    var aName = a[name],
                            bName = b[name];
                    if (aName === bName) {
                        arr.sort(by('name'));             return 0;
                    }
                    if (typeof aName === typeof bName) {
                        return aName > bName ? 1 : -1;
                    }
                    return typeof a < typeof b ? -1 : 1;
                }else{
                    throw {
                        name:"Error",
                        message:"Expected an object when sorting by "+name
                    };
                }
            }
        }
        var arr=[
            {
                name:'s',
                lastName:'jr'
            },{
                name:'z',
                lastName:'a'
            },{
                name:'a',
                lastName:'y'
            }]
//Object
lastName: "y"
name: "a"
__proto__: Object
,
Object
lastName: "jr"
name: "s"
__proto__: Object
,
Object
lastName: "a"
name: "z"
__proto__: Object

三、影响原数组长度　　

改变原数组(添加返回长度，删除返回删除的元素)：

push:向数组的末尾添加元素->返回数组长度　　　

arr.push([])
//5
arr
//[1, 2, 3, "a", Array[0]]

pop:删除末尾元素->并返回末尾元素

arr.pop()
//[]
arr
//[1, 2, 3, "a"]

shift: 删除一个元素，并返回第一个元素的值

arr.shift()
//1
arr
//[2, 3, "a"]

unshift: 向数组的开头添加元素->返回新的长度

arr.unshift("b")
//4
arr
//["b", 2, 3, "a"]

splice：向/从数组中添加/删除项目->返回被删除的项目

数组其实就是对象，所以delete运算符可以用来从数组中称除元素。但是会留下一个空洞。delete numbers[2]//原位置变成了undefined。

　　如果想递减后面每个元素的属性，则用splice。

　　但是，因为被删除属性后面的每个属性必须被移除，并且以一个新的键值重新插入，这对于大型数组来说可能会效率不高。-good parts p59

　　

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

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

arr
//["b", 2, 3, "a"]
arr.splice(2,0,"William")
//[]
arr
//["b", 2, "William", 3, "a"]

四、寻找某个元素在数组的位置

返回要查找项在数组中的位置或-1。参数：要查找的项，查找起点位置的索引。 以===原则查找

对象数组也一样哦~

indexOf:从头查找

lastIndexOf:从末尾查找

五、迭代器

5个迭代方法，都接收两个参数:要在每一项上运行的函数和（可选的）运行该函数的作用域对象--影响this的值。

传入这些方法的函数会接收三个参数：数组项的值、该项在数组中的位置和数组对象本身。都不会修改数组中的包含的值。

every:如果该函数对每一项都返回true,则返回true;　　

var numbers=[1,2,3,4,5,4,3,2,1]
//undefined
var everyResult=numbers.every(function(item,index,array){return (item>2)})
//undefined
everyResult
//false

　　some:如果该函数对任一项返回true,则返回true;

var everyResult=numbers.some(function(item,index,array){return (item>4)})
//undefined
everyResult
//true

　　filter:返回该函数会返回true的项组成的数组;

var everyResult=numbers.filter(function(item,index,array){return (item>2)})
//undefined
everyResult
//[3, 4, 5, 4, 3]

　　map:返回每次函数调用的结果组成的数组;

var everyResult=numbers.map(function(item,index,array){return (item>2)})
//undefined
everyResult
//[false, false, true, true, true, true, true, false, false]

　　forEach:无返回值;本质上与使用for循环迭代数组一样。

归化数组的方法：迭代数组所有项，然后构建一个最终返回的值，reduceRight反向。

参数：在每一项上调用的函数，作为缩小基础的初始值（可选）。

函数接收参数：前一个值，当前值，项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发现在数组的第二项目上，因此第一个参数是数组的第一项，第二个参数是数组的第二项。

reduce:可以执行求数组所有值和的操作

numbers.reduce(function(pre,cur,index,array){return pre+cur})
//25

　　reduceRight:除了遍历方向，其他都相同。

　　兼容低版本浏览器链接：http://www.cnblogs.com/rubylouvre/archive/2011/07/27/2117862.html

　　 六、将数组元素拼接为字符串

　　join:把数组所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。

var arr=[1,2,3]
//undefined
arr.join("_")
//"1_2_3"
arr
//[1, 2, 3]