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;
}