JavaScript数组基础编程题归纳

　　之前的随笔“JavaScript中数组类型的属性和方法”中有介绍很多数组类型的方法，但都是一些理论。最近在练习在线编程题，发现自己还是习惯于用常规的循环来答题，对于数组的方法的使用还是不够熟练。这次笔记归纳了一下基础的数组编程题，意在加深对数组各种方法的印象，以便理解使用。

---

1.计算给定数组arr所有元素的和（number类型）

• 常规循环

   function sum(arr) {
       var s = 0;
       for (var i=arr.length-1; i>=0; i--) {
           s += arr[i];
       }
       return s;
   }

• forEach()遍历

   function sum(arr) {
       var s = 0;
       arr.forEach(function(val, idx, arr) {
           s += val;
       }, 0);
       return s;
   };

• reduce()归并

   function sum(arr) {
       return arr.reduce(function(prev, curr, idx, arr){
           return prev + curr;
       });
   }

• eval()与join()

   function sum(arr) {
       return eval(arr.join("+"));
   };

2.移除指定数组arr中所有与item相等的元素

• 不修改arr

   //创建新数组，push()
   function remove(arr, item) {
       var result = [];
       for(var i = 0; i < arr.length; i++){
            if(arr[i] != item){
               result.push(arr[i]);
            }
       }
       return result;
   }
  
   // filter()迭代
   function remove(arr, item) {
       return arr.filter(function(x) { return x !== item; });
   }

• 直接修改arr

   function removeWithoutCopy(arr, item) {
       for(var i = 0; i < arr.length; i++){
           if(arr[i] == item){
               arr.splice(i,1);
               i--;
           }
       }
       return arr;
   }

3.在数组arr指定位置添加元素item（不修改arr）

• 在数组开头添加

   //****复制数组再添加（concat/slice + unshift/splice）****
   function prepend(arr, item) {
       var result = arr.concat();   //var result = arr.slice(0);
       result.unshift(item);        //result.splice(0,0,item);
       return result;
   }
  
   //*****直接拼接****
  
   //利用concat
   function prepend(arr, item) {
       return [item].concat(arr);
   }
  
   //使用push.apply
   function prepend(arr, item) {
       var newArr=[item];
       [].push.apply(newArr, arr);
       return newArr;
   }

• 在数组末尾添加

   //普通的迭代拷贝
   var append = function(arr, item) {
       var newArr = [];
       for (var i = 0; i < arr.length; i++) {
           newArr.push(arr[i]);
       }
       newArr.push(item);
       return newArr;
   };
  
   // 使用slice浅拷贝+push组合
   var append2 = function(arr, item) {
       var newArr = arr.slice(0);           // slice(start, end)浅拷贝数组
       newArr.push(item);
       return newArr;
   };
  
   //使用concat将传入的数组或非数组值与原数组合并,组成一个新的数组并返回
   var append3 = function(arr, item) {
       return arr.concat(item);
   };

• 在数组index处添加

  //复制数组，在添加
  function insert(arr, item, index) {
      var newArr=arr.concat();        //var newArr=arr.slice(0);
                                      //var newArr=[]; [].push.apply(newArr, arr);
      newArr.splice(index,0,item);
      return newArr;
  }
  
  //利用slice+concat
  function insert(arr, item, index) {
      return arr.slice(0,index).concat(item,arr.slice(index));
  }

4.在数组arr指定位置删除元素（不修改arr）

• 删除数组开头元素

   //复制，再删除
   function curtail(arr) {
       var newArr = arr.concat();  //var newArr = arr.join().split(',');
                                   //var newArr=[];  [].push.apply(newArr, arr);
       newArr.shift();
       return newArr;
   }
  
   //利用filter
   function curtail(arr) {
       return arr.filter(function(v,i) {
           return i!==0;
       });
   }
  
   //利用slice
   function curtail(arr) {
       return arr.slice(1);
   }

• 删除数组末尾元素

   function truncate(arr) {
       return arr.slice(0,arr.length-1);
   }

5.合并数组（不修改arr）

• 利用concat()

   function concat(arr1, arr2) {
       return arr1.concat(arr2);
   }

• 利用 splice + push.apply

   function concat(arr1, arr2) {
       var newArr=arr1.slice(0);
       [].push.apply(newArr, arr2);
       return newArr;
   }

6.统计数组arr中元素item出现的次数

• 常规循环

   function count(arr, item) {
       var sum = 0;
       for(var i = 0; i < arr.length; i++){
           if( arr[i] == item){
               sum ++;
           }
       }
       return sum;
   }

• 利用filter()

  function count(arr, item) {
      return arr.filter(function(x){
          return (x==item);
      }).length
  }

• 利用forEach()

  function count(arr, item) {
      var count = 0;
      arr.forEach(function(x) {
           x === item ? count++ : 0;
       });
       return count;
  }    

• 利用reduce()

   function count(arr, item) {
       var count = arr.reduce(function(prev, curr) {
           return curr === item ? prev+1 : prev;
       }, 0);
       return count;
   }

7.输出数组arr中重复出现过的元素

• 双循环

   function duplicates(arr) {
       var result = [];
       for(var i=0;i<arr.length;i++){
           for(var j=i+1;j<arr.length;j++){
               if(arr[i]==arr[j]){
                   result.push(arr[i]);
                   arr.splice(i,1);
                   arr.splice(j,1);
                   i=i-2;
                   j=j-2;
               }
           }
       }
       return result;
   }

• 先排序，再循环

   function duplicates(arr) {
       var copy = arr.sort(),
           result = [];
       for(var i in copy){
           if(copy[i]==copy[i-1] && result.indexOf(copy[i])==-1) result.push(copy[i]);
       }
       return result;
   }

• 利用forEach()

   function duplicates(arr) {
       var result = [];
       arr.forEach(function(elem){
          if(arr.indexOf(elem) != arr.lastIndexOf(elem) && result.indexOf(elem) == -1){
              result.push(elem);
          }
       });
       return result;
   }

8.数组去重

 Array.prototype.uniq = function () {
     var flag = false;
     for(var i = 0; i < this.length; i++){
         if(this[i] !== this[i]) flag = true;
         for(var j = i+1; j < this.length;){
             if(this[i] === this[j] ||(flag && this[j] !== this[j])){
                 this.splice(j,1);
             }else{
                 j++;
             }
         }
     }
     return this;
 }