JS 数组方法总结

一、创建Array

创建数组主要有两种方法，第一种是使用数组构造函数，第二种是使用数组字面量表示法。

1. 使用数组构造函数
   如：var arr = new Array();
   如果预先知道数组的长度，那么也可以直接给构造函数传递该长度。
   如：var arr = new Array(20);
   如果知道数组中应该包含的项，就直接在构造的时候，传递数组中的应该包含的项。
   如：var arr = new Array(1,2,3);
2. 使用数组字面量表示法
   如：var arr = [1,2,3,4];
   var arr2 = [];

二、数组的操作

1. 数组方法
   push();----向数组末端添加数据项；
   pop();---获取数组的最尾部的一个数据项；
   shift();---获取数组的头部一项的数据信息；
   unshift();--与shift完全相反，就是向数组的头部插入数据项信息；
   以上方法会直接修改数组本身

var a = [{n: 1},{z:5}];
        var b = a;
        b.unshift('aa');
//a = b = ["aa",{"n":1},{"z":5}]

2. 验证是否为数组

if(value instanseof Array){}
if(Array.isArray(value)){}//该方法只使用与高版本的浏览器：IE9+、Firefox4+/Chrome

3. 具体的编程实例

1. 添加元素（数组末尾添加元素，不要直接修改数组 arr，结果返回新的数组 ）

//方法一：slice()和push()结合
function append(arr, item) { 
  var newArr = arr.slice(0); // slice(start, end)浅拷贝数组 
  newArr.push(item); 
  return newArr; 
}; 
//方法二：普通的迭代拷贝
function append(arr, item) { 
          var length = arr.length, 
            newArr = []; 
          for (var i = 0; i < length; i++) { 
            newArr.push(arr[i]); 
          } 
          newArr.push(item); 
          return newArr; 
        }; 
//方法三：使用concat
function append(arr, item) { 
    return arr.concat(item); 
} 

2）添加元素（添加任意位置的元素，不要直接修改数组 arr，结果返回新的数组。）

//方法一：使用普通的迭代拷贝
function insert(arr, item, index) {
            var newArr=[];
            for(var i=0;i<arr.length;i++){
                newArr.push(arr[i]);
            }
            newArr.splice(index,0,item);
            return newArr;
        } 
//方法二：slice()和splice()结合
function insert(arr, item, index) {
            var newArr=arr.slice(0);
            newArr.splice(index,0,item);
            return newArr;
        } 
//方法三：concat()和splice()结合
function insert(arr, item, index) {
            var newArr=arr.concat();
            newArr.splice(index,0,item);
            return newArr;
        } 

3. 删除元素（删除数组最后一个元素，不要直接修改数组 arr，结果返回新的数组 。）

//方法一：使用普通的迭代拷贝
function truncate(arr, item) {
            var newArr=[];
            for(var i=0;i<arr.length-1;i++){
                newArr.push(arr[i]);
            }
            return newArr;
        }
//concat()和pop()结合
function truncate(arr) {
            var newArr = arr.concat();
            newArr.pop(); 
            return newArr;
        }

4. 删除元素（删除数组第一个元素，不要直接修改数组 arr，结果返回新的数组 。）

//方法一：使用普通的迭代拷贝
function curtail(arr) {
            var newArr = [];
            for(var i=1;i<arr.length;i++){
                              newArr.push(arr[i]); 
                       } 
            return newArr;
        }
//concat()和shift()结合
function curtail(arr) { 
          var newArr = arr.concat(); 
          newArr.shift(); 
          return newArr; 
} 
//方法三：slice()
function curtail(arr) { 
          return arr.slice(1); 
} 

4. 合并数组（不要直接修改数组 arr，结果返回新的数组）

//方法一：使用普通的迭代拷贝
function concat(arr1, arr2) {
            var newArr=[];
            for(var i=0;i<arr1.length;i++){
                newArr.push(arr1[i]);
            }
            for(var j=0;j<arr2.length;j++){
                newArr.push(arr2[j]);
            }
            return newArr;
        }
//方法二：concat()方法
function concat(arr1, arr2) { 
          return arr1.concat(arr2); 
} 
//方法三：slice()和push()结合
function concat(arr1, arr2) { 
        var newArr=arr1.slice(0); 
        for(var i=0;i<arr2.length;i++){ 
            newArr.push(arr2[i]); 
        } 
       return newArr; 
    } 

5. 移除数组中的元素

//方法一：splice()方法
function remove(arr, item) { 
      var newArr = arr.slice(0); 
      for(var i=0; i<newArr.length; i++) { 
        if(newArr[i] == item) { 
          newArr.splice(i, 1); 
        } 
      } 
      return newArr; 
    } 
    var arr = [1,2,3,4,2]; 
    var item = 2; 
    console.log(remove(arr, item)); 
    console.log(arr); 
//方法二：push()方法
function remove(arr,item){ 
    var newarr = []; 
    for(var i=0;i<arr.length;i++){ 
         if(arr[i] != item){ 
         newarr.push(arr[i]); 
        } 
    } 
    return newarr; 
 } 

原文链接(http://blog.csdn.net/u010297791/article/details/53000603)