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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
     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
     }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 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
     }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 这个版本的好处是, 一旦有一个假,循环就会终止,节省性能.
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;
     }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 这个版本的好处是, 一旦有一个假,循环就会终止,节省性能.
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;
     }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
这个我不确定对不对.有点忘了,嘿..
我记得
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;
     }