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);//3
            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);//5
         }
         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([]));//7
            console.log(a);//[Array[0], Array[3], 1, "x", true, undefined, null]
            console.log(b.unshift("a"));//4
            console.log(b);//["a", false, undefined, null]
            console.log(c.unshift("[]"));//报错
            console.log(d.unshift("[]"));//报错
            console.log(e.unshift([]));//1
            console.log(e);//[Array[0]]
            console.log(b.push([]));//5
            console.log(b);//["a", false, undefined, null, Array[0]]
         }
         foo();
</script>