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>