重写数组方法

重写数组方法

• pop()用于删除数组的最后一个元素并返回删除的元素。

  var arr = [1,2,3,4];
  // 删除数组最后一个元素
  Array.prototype.myPop = function() {
      // 保存被删除的元素，便于作为返回值
      var temp = this[this.length-1];
      this.length--;
      return temp;
  }
  console.log(arr.myPop());  // 4
  console.log(arr);     // [1,2,3]
  

• push():向数组的末尾添加一个或多个元素，并返回新的长度。

  var arr = [1,2,3,4];
  // 在数组末尾追加元素
  Array.prototype.myPush = function() {
  	//函数传参时会将实参存储到arguments对象中，循环遍历arguments对象将元素追加到数组末尾
      for(var i = 0; i < arguments.length; i++) {
          this[this.length] = arguments[i];
      }
      return this.length;    //返回新的数组长度
  }
  console.log(arr.myPush(5,6));  // 6
  console.log(arr);	// [1,2,3,4,5,6]
  

• shift():用于把数组的第一个元素从其中删除，并返回第一个元素的值。

  var arr = [1,2,3,4];
  // 删除数组首位元素，作为返回值返回
  Array.prototype.myShift = function() {
      var temp = this[0];		//保存需要的返回值
      for(var i = 1; i < this.length; i++) {
          this[i-1] = this[i];	//数组元素左移一位
      }
      this.length--;       //数组长度减一
      return temp;
  }
  console.log(arr.myShift());  // 1
  console.log(arr);	// [2,3,4]
  

• unshift():向数组的开头添加一个或更多元素，并返回新的长度。

  var arr = [1,2,3,4];
  //在数组首位添加n个元素
  //思路：先将数组长度变为原数组长度 + arguments对象的长度，然后将原数组元素右移，最后将arguments对象中的元素依次放入数组
  Array.prototype.myUnshift = function() {
      for(var i = this.length + arguments.length - 1; i >= 0; i--) {
          if(i > arguments.length - 1) {
              this[i] = this[i-arguments.length];    // 原数组元素右移
          } else {
              this[i] = arguments[i];			//新添加的元素一次放入数组
          }
      }
      return this.length;
  }
  console.log(arr.myUnshift(5，6));  // 6
  console.log(arr);  //[5,6,1,2,3,4]
  

• reverse() 方法用于颠倒数组中元素的顺序。

  var arr = [1,2,3,4];
  //数组反转
  Array.prototype.myReverse = function() {
      var temp;    //临时保存需要交换位置的数组元素
      for(var i = 0; i < this.length / 2; i++) {
          temp = this[i];
          this[i] = this[this.length-1-i];
          this[this.length-1-i] = temp;
      }
      return this;
  }
  console.log(arr.myReverse());  // [4,3,2,1]
  

• indexOf() 方法可返回数组中某个指定的元素位置。

  var arr = [1,2,3,4];
  Array.prototype.myIndexOf = function() {  
      for(var i = 0; i < this.length; i++) {
          if(arguments[0] === this[i]) {
              return i;
          }
      }
      return -1;     //找不到则返回-1
  }
  console.log(arr.myIndexOf(2));  // 1
  

forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数

var arr = [1,2,3,4];
Array.prototype.myForEach = function(func,obj){
    for(var i = 0; i < this.length; i++) {
        obj?func.call(obj,this[i],i,this):func(this[i],i,this);
    }
}
arr.myForEach(function(item,index,arr){
    console.log(item,index,arr);  //item为数组元素，index为下标，arr为数组
    console.log(this);   //{name:'zhangsan'}
},{name:'zhangsan'})

every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）

• 如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。

• 如果所有元素都满足条件，则返回 true。

  var arr = [1,2,3,4];
  Array.prototype.myEvery = function (func,obj) {
      for (var i = 0; i < this.length; i++) {
      	//三目运算符，如果有传第二个参数则修改this指向
          if(obj?!func.call(obj,this[i],i,this):!func(this[i],i,this)) {
              return false;
          }
      }
      return true;
  }
  var result = arr.myEvery(function(item){
      console.log(this);
      return item > 0;
  },{name:'zhangsan'})
  console.log(result); //循环打印四次{name:'zhangsan'}、一个true
  

some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。

• 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。

• 如果没有满足条件的元素，则返回false。

var arr = [1,2,3,4];
Array.prototype.mySome = function(func,obj) {
    for (var i = 0; i < this.length; i++) {
        if(obj?func.call(obj,this[i],i,this):func(this[i],i,this)){
            return true;
        }
    }
    return false;
}
var result = arr.mySome(function(item){
    console.log(this);
    return item > 1; //短路原则
},{name:'zhangsan'})
console.log(result);   //{name:'zhangsan'} {name:'zhangsan'} ,true

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

var arr = [1,2,3,4];
Array.prototype.myFilter = function(func,obj) {
    //定义新数组保存符合条件的元素
    var result = [];
    for(var i = 0; i < this.length; i++) {
        if(obj?func.call(obj,this[i],i,this):func(this[i],i,this)) {
            result.push(this[i]);
        }
    }
    return result;
}
var result = arr.myFilter(function(item){
    console.log(this);  //{name:'zhangsan'}
    return item > 2;
},{name:'zhangsan'})
console.log(result); // {name:'zhangsan'}*4,  [3,4]

map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

var arr = [1,2,3,4];
Array.prototype.myMap = function(func,obj) {
    var result = [];
    for(var i = 0; i < this.length; i++) {
        result.push(obj?func.call(obj,this[i],i,this):func(this[i],i,this));
    }
    return result;
}
var result = arr.myMap(function(item){
    console.log(this); //this指向传入的第二个实参，如果为空，则指向全局 
    return item + 1; //新数组 数组元素加一
},{name:'zhangsan'});
console.log(result);  //{name:'zhangsan'}*4, [2,3,4,5]