js小白模拟系列:模拟数组 forEach,filter,map,every,some,reduce

forEach

Array.prototype.forEach = function (fn,context) {// 如果需要可以更改this指向.
var context = context || window;
        var self = this;
        var len = self.length;
        for(var i = 0; i < len;i++ ) {
          fn.call(context,self[i],i,self);
        }
     }
     
     var arr = [1,2,3,4,5,6,9];
     var obj = {name: 'obj'};
     arr.forEach(function (item,index,self) {
       console.log(this.name);
        console.log(item,index,self);
     },obj)

filter

     Array.prototype.filter = function (fn,context) {// 如果需要可以更改this指向.
var context = context || window;
        var self = this;
        var newArr = [];
        var len = self.length;
        for(var i = 0; i < len;i++ ) {
          if(fn.call(context,self[i],i,self)) {
            newArr.push(self[i]);// 如果想要新数组跟源数组不产生一点关系, 这里可以深度克隆 self[i]
//        if(typeof(self[i]) == 'object'){
//          if(Array.isArray(self[i])){
//            newArr.push(clone(self[i]),[]);
//          }else{
//            newArr.push(clone(self[i]),{});
//          }
//          }
          };
        }
        return newArr
     }

map 深度克隆方式. 下面的我们就不用深度克隆方式了.

 Array.prototype.map = function (fn,context) {// 如果需要可以更改this指向.
var context = context || window;
        var self = this;
        var newArr = [];
        var len = self.length;
        for(var i = 0; i < len;i++ ) {
          if(typeof(self[i]) == 'object'){
            var selfi = clone(self[i],{});
          }else{
            var selfi = self[i];
          }
          newArr.push(fn.call(context,selfi,i,self));
        }
        return newArr
     }

every
其实every 和 some 刚接触的时候感触挺大的,
当时对这种连续判断感到挺费力的.

// 这个版本的好处是, 一旦有一个假,循环就会终止,节省性能.
Array.prototype.every = function (fn,context) {
var context = context || window;
        var self = this;
        var len = self.length;
        for(var i = 0; i < len;i++ ) {
          if(!fn.call(context,self[i],i,self)){
            return false;
          };
        }
        return true;
     }

这个版本能确保都遍历一遍.
Array.prototype.every = function (fn,context) {
var context = context || window;
        var self = this;
        var len = self.length;
        var flag = true;
        for(var i = 0; i < len;i++ ) {
          if(!fn.call(context,self[i],i,self)){
            flag = false;
          };
        }
        return flag;
     }

some和every很像.

// 这个版本的好处是, 一旦有一个假,循环就会终止,节省性能.
Array.prototype.every = function (fn,context) {
var context = context || window;
        var self = this;
        var len = self.length;
        for(var i = 0; i < len;i++ ) {
          if(fn.call(context,self[i],i,self)){
            return true;
          };
        }
        return false;
     }

这个版本能确保都遍历一遍.
Array.prototype.every = function (fn,context) {
var context = context || window;
        var self = this;
        var len = self.length;
        var flag = false;
        for(var i = 0; i < len;i++ ) {
          if(fn.call(context,self[i],i,self)){
            flag = true;
          };
        }
        return flag;
     }

reduce
其实这是这几个函数中最难的,
我刚开始都怀疑这个函数会有人用嘛? 会有人用的.
js数组方法reduce经典用法代码分享

这个我不确定对不对.有点忘了,嘿..
我记得
Array.prototype.reduce = function (fn,context,init) {
      var context = context || window;
      var self = this;
      if(typeof(init) === undefined){
    var   init = self[0];
       var i = 1;
}else {
  var  init = init;
  var i = 0;
}
      var len = self.length;
      for(; i < len;i++ ) {
       icur = fn.call(context,init,self[i],i,self);
      }
      return init;
     }