A brief analysis of Prototype source code each method of Enumerable part_prototype

In JavaScript, there is no trace of Enumerable at all, because this part was borrowed from Ruby by the author of Prototype. And Enumerable has no chance of direct application in practice. It is mixed into other objects. It can be said to be a "parent class" of other objects (but it only calls the extend method of Object and makes a direct copy of the method). .

I am not familiar with Ruby, but looking at some methods in Enumerable, they are somewhat similar to those in Python.

One of the most important methods of Enumerable is each. You should be familiar with each method. Its function is to traverse all elements of a sequence and perform corresponding processing. However, most of them are applied to arrays. For example, the forEach method of native arrays and chain calls in jQuery all rely on the each method. Because the jQuery selector returns an array of DOM objects, and then calls each on the returned array to process each element separately.

Generally, each has two parameters: one is the context corresponding to the iterative processing function and method.

Copy code The code is as follows:

var each = Array.prototype.forEach || function( iterator,context){
for(var i = 0,len = this.length ; i < len ; i ){
iterator.call(context,this[i],this);
}
};

Following the above method, we extend the Array object with a print method that prints all current elements.

Copy code The code is as follows:

Array.prototype.each = Array.prototype.forEach | | function(iterator,context){
for(var i = 0,len = this.length ; i < len ; i ){
iterator.call(context,this[i],i,this) ;
}
};
Array.prototype.print = function(){
this.each(function(item){
console.log(item);
}) ;
}
console.log([1,2,3,4].print());//1,2,3,4

In Enumerable, each It does not correspond to a specific method. As mentioned earlier, Enumerable is not applied on the occasion, but is applied to other objects as a "parent class". Therefore, its each method calls the "subclass" _each method, so any mixed Enumerable The object of the module must provide an _each method as the iteration code that acts on the actual loop.

Now implement a _each method and an each method on Array.prototype, implementation one:

Copy code The code is as follows:

Array.prototype.each = function(iterator,context){
this._each(iterator,context)
}
Array.prototype._each = function (iterator,context){
for(var i = 0,len = this.length ; i < len ; i ){
iterator.call(context,this[i],i,this);
}
};

As mentioned before, _each only needs to provide an iterator parameter, but since _each has also been extended to Array.prototype, when implementing Also comes with the context parameter. Therefore, in Enumerable, the second context parameter of _each is not used, and whether it is implemented or not has no effect on each. Therefore, the above implementation should not rely on the context of _each, so modify each as follows:

Copy code The code is as follows:

Array.prototype.each = function(iterator,context){
var index = 0;
this._each(function(value){
iterator.call(context,value, index );
})
}

In this way, the independence of each method is improved, and this Enumerable can also be used in subsequent Hash. Any traversed object can obtain the corresponding method from Enumerable as long as it provides the _each method.

Therefore, if the above print example is implemented in the form of Enumerable, the following result will be obtained:

Copy code The code is as follows:

var Enumerable = {};
Enumerable.each = function(iterator, context) {
var index = 0;
this._each(function(value){
iterator .call(context, value, index );
});
return this;
};
Enumerable.print = function(){
this.each(function(item){
console.log(item);
})
};
Array.prototype._each = function(iterator,context){
for(var i = 0,len = this. length ; i < len ; i ){
iterator.call(context,this[i],i,this);
}
};
//The following implementation source code is used The extend method
for(var key in Enumerable){
Array.prototype[key] = Enumerable[key];
};
[1,2,3,4].print() ;//1,2,3,4

Understanding the implementation of each is the key to understanding the Enumerable object. The subsequent Array and Hash are both mixed into the Enumerable object, which is quite important.
Please indicate that the reprint comes from Xiaoxi Shanzi [http://www.cnblogs.com/xesam/]