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]

巴特西

Array方法总结

最新文章

热门文章