JS中数组方法小总结

1.array.concat(item……)

返回：一个新数组

该方法产生一个新数组，它包含一份array的浅复制，并把一个或多个参数item附加在其后。如果参数item是一个数组，那么它的每个元素会被分别添加。例如：

 var a = [1,2,3];

 document.write(a.concat(4,5));

 或者

 var b= [4,5];

 document.write(a.concat(b));

在连接的时候不会将数组中数据类型变成字符串，也不会改变原数组。例如：

<script type="text/javascript">

         var foo=function  () {

            var a=[1,2,3],b=[4,5];

            if(typeof (a.concat(b)[3])==="string"){

                alert("string");

            }else if(typeof (a.concat(b)[3])==="number"){

                alert("number");//number

            }else{

                alert("other");

            }

            console.log(a);//[1,2,3]

            console.log(b);//[4,5]

         }

         foo();

</script>

当参数中有一个是空数组时，

var e=[];

var a=[1,2,3];

console.log(a.concat(e));//[1,2,3],不是[1,2,3,""]

console.log(e.concat(a));//[1,2,3]

2.array.join(separator)

返回：一个新字符串

该方法把一个数组构造成一个字符串（把数组所有元素放进一个字符串中），然后元素与元素之间用separator分隔开。

具体来讲，首先先把array中的每一个元素构造成一个字符串，接着用一个separator分隔符把他们连接在一起。默认的separator是逗号','。想做无间隔的连接，可以把separator设为空字符串""。例如：

 var foo=function  () {

             var a=[1,2,3],b=[4,5];

             var c=a.concat(b).join("");

             console.log(typeof c);

          }

 foo();

如果想要将大量的字符串片段组合到一个字符串，把这些片段放到一个数组中并用join方法连接起来通常比+元素运算符连接起来要快。

在IE6/7中，join方法比+运算符效率快，IE8以后的版本对+运算符进行了特别的优化，性能已经显著高于join方法，建议首选使用+方法。

当数组为空数组时，

var e=[];

console.log(e.join(","));语句没有执行结果

3.array.pop()

返回：被移除的那个元素

移除array中最后一个元素并返回该元素。如果该array是empty，它会返回undefined。数组为空时返回undefined。例如：

 <script type="text/javascript">

          var foo=function  () {

             var a=[1,2,3];

             var c=a.pop();

             console.log(c);//

             console.log(a);//[1,2]

          }

          foo();

 </script>

该方法不能用于null，会报错

 <script type="text/javascript">

          var foo=function  () {

             var a=[1,2,3];

             var b=[];

             var d=null;

             console.log(b.pop());//undefined

             console.log(d.pop());//报错

          }

          foo();

 </script>

pop可以这样实现：

Array.method("pop",function(){

     return this.splice(this.length-1,1)[0];

});

4.array.push(item……)

返回：原数组的新长度

push方法把一个或多个参数item附加到一个数组的尾部。和concat方法不同的是，这个方法会改变元素组，也就是说将item加入原数组中。

 <script type="text/javascript">

          var foo=function  () {

             var a=[1,2,3];

             var b=["x","y","z"];

             var c=a.push(b,true);

             console.log(a);//[1,2,3,Array(3),true]，这里a的长度为5

             console.log(c);//

          }

          foo();

 </script>

push可以这样实现：

 Array.method("push",function(){

   this.splice.apply(this,[this.length,0].

       concat(Array.prototype.slice.apply(ayguments))

   );

   return this.length;

 )};

5.array.reverse()

返回：array本身反转之后

将array里的元素的顺序反转，并返回array本身，例如：

 var a=["a","b","c"];

 var b=a.reverse();

 console.log(a);//["c","b","a"]

 console.log(b);//["c","b","a"]

6.array.shift()

返回：移除数组第一个元素并返回该元素。如果这个数组是空的，则返回undefined

shift通常比pop慢得多，例如：

 var a=[[2,3,4],1,"x",true,undefined,null];

 var b=[false,undefined,null];

 var c=null;

 var d=undefined;

 var e=[];

 console.log(a.shift());//[2,3,4]

 console.log(b.shift());//false

 console.log(e.shift());//undefined

 console.log(c.shift());//报错
10 console.log(b);//[undefined,null]

该方法是在数组本身上操作。

7.array.slice(start,end)

返回：截取的新数组

首先对array中的一段进行浅复制。先复制array[start],一直复制到array[end]为止。end参数是可选的，默认值是该数组长度array.length。

slice方法不可以用在null和undefined上，会报错。

当array为空数组时,返回空数组

var e=[];

console.log(e.slice(0));//[]

slice的操作时不影响原数组的，例如：

 <script type="text/javascript">

          var foo=function  () {

             var a=[[2,3,4],1,"x",true,undefined,null];

             var b=[false,undefined,null];

             var c=null;

             var d=undefined;

             var e=[];

             //slice的方法

             console.log(b.slice(0,1));//[false]

             console.log(b);//[false, undefined, null]

             console.log(b.slice(1,2));//[undefined]

          }

          foo();

 </script>

8.array.sort(comparefn)

返回：一个排序过的数组，在原数组上排序

不过，排序方法不稳定。例如： var n=[4,8,15,16,23,42]; ，执行n.sort();之后，得到的却是[15,16,23,4,42,8]，有点类似于字典排序。因为该方法将每个元素都转化成了字符串。

举例：

 <script type="text/javascript">

             var foo=function  () {

             var a=[[2,3,4],1,"x",true,undefined,null];

             var b=[false,undefined,null];

             var c=null;

             var d=undefined;

             var e=[];

             //sort的方法

             console.log(e.sort());//[]

             console.log(a.sort());//[1, Array[3], null, true, "x", undefined]

             console.log(b.sort());//[false, null, undefined]

             console.log(c.sort());//报错

             console.log(d.sort());//报错

          }

          foo();

 </script>

如果想要实现数字的从小到大排序，可以将函数改成如下所示：

 n.sort(function(a,b){

   return a-b;//等于0，则两个数相等，小于0，则第一个数排在前面

 }

 )

若是从大到小，改成b-a即可。b-a为负数，则前一个数排在后一个数前面。

如果是想要实现自定义属性的排序，可以进行如下处理：

 var objectList=new Array();

          function Person(name,age){

             this.name=name;

             this.age=age;

          }

         objectList.push(new Person('a',20));

         objectList.push(new Person('b',25));

         objectList.sort(function(a,b){

             return a.age-b.age;

         }

 );

如果想要实现可改变的属性排序，可以进行一下处理：

 var objectList=new Array();

          function Person(name,age){

             this.name=name;

             var _age;

             this.age=function(){

                 if(arguments){

                     _age=arguments[0];

                 }else{

                     return age;

                 }

             }

          }

         objectList.push(new Person('a',20));

         objectList.push(new Person('b',25));

         objectList.sort(function(a,b){

             return a.age()-b.age();

             });

         );

9.array.splice(start,deleteCount,item……)

返回：一个包含被移除元素的数组。在原数组上操作，主要功能就是删除数组元素，或者替换。

从array中移除一个或多个元素，并用新的item替换他们。参数start是从数组array中移除元素的开始位置。参数deleteCount是要移除的元素个数。如果有额外的参数，那些item会插入到被移除元素的位置上。

例如：

 <script type="text/javascript">

             var foo=function  () {

             var a=[[2,3,4],1,"x",true,undefined,null];

             var b=[false,undefined,null];

             var c=null;

             var d=undefined;

             var e=[];

             console.log(a.splice(1,1));//[1]

             console.log(b.splice(1,1));//[undefined]

             console.log(b.splice(1,1,"splice"));//[null]

             console.log(b);//[false, "splice"]

             console.log(c.splice(1,1));//报错

             console.log(d.splice(1,1));//报错

             console.log(e.splice(1,1));//[]

          }

          foo();

 </script>

10.array.unshift(item……)

返回：添加后的数组的长度，在原数组上操作

与push方法类似，用于把元素添加到数组中，但是是从开始部分添加不是从尾部添加。

例如：

 <script type="text/javascript">

             var foo=function  () {

             var a=[[2,3,4],1,"x",true,undefined,null];

             var b=[false,undefined,null];

             var c=null;

             var d=undefined;

             var e=[];

             console.log(a.unshift([]));//

             console.log(a);//[Array[0], Array[3], 1, "x", true, undefined, null]

             console.log(b.unshift("a"));//

             console.log(b);//["a", false, undefined, null]

             console.log(c.unshift("[]"));//报错

             console.log(d.unshift("[]"));//报错

             console.log(e.unshift([]));//

             console.log(e);//[Array[0]]

             console.log(b.push([]));//

             console.log(b);//["a", false, undefined, null, Array[0]]

          }

          foo();

 </script>

巴特西

JS中数组方法小总结

最新文章

热门文章