Javascript reuse method with apply and arguments _ javascript skills

This article mainly introduces how to reuse javascript by using apply and arguments. If you need it, you can refer to it. First, there is a singleton object, which involves many static tool methods. One of them is each, which is used to traverse arrays or objects.

The Code is as follows:

Var nativeForEach = []. forEach
Var nativeMap = []. map
Var util = {
Each: function (obj, iterator, context ){
If (obj = null) return
If (nativeForEach & obj. forEach === nativeForEach ){
Obj. forEach (iterator, context)
} Else if (obj. length = + obj. length ){
For (var I = 0; I <obj. length; I ++ ){
If (iterator. call (obj [I] | context, obj [I], I, obj) = true) return
}
} Else {
For (var k in obj ){
If (iterator. call (obj [k] | context, obj [k], k, obj) = true) return
}
}
},
Map: function (obj, iterator, context ){
Var results = []
If (obj = null) return results
If (nativeMap & obj. map === nativeMap) return obj. map (iterator, context)
This. each (obj, function (val, I, coll ){
Results [I] = iterator. call (context, val, I, coll)
})
Return results
}
}

There are also tool functions such as every and some for set (Array, Hash) operations. Util. xx is used.

If a collection class is defined, this class contains set data.

The Code is as follows:

Function Collection (data ){
This. data = data | []
// Some other property
// This. xxx = yyy
}
Collection. prototype = {
// Some method
}

You can easily copy the methods on util to the Collection class, as shown in figure

The Code is as follows:

Function copyMethod (clazz, obj ){
For (var method in obj ){
Clazz. prototype [method] = function (){
Var args = []. slice. call (arguments)
Var target = this. data
Args. unshift (target)
Obj [method]. apply (obj, args)
}
}
}
CopyMethod (Collection, util)

In this way, the Collection instance has the util method. The Collection object (the first parameter) of the util operation is the this. data of the Collection. You can directly traverse this. data as follows.

The Code is as follows:

Var coll = new Collection ([10, 20, 30])

// Traverse
Coll. each (function (k ){
Console. log (k)
})

// Operation
Var arr = coll. map (function (k ){
Return k-5
})
Console. log (arr) // 5, 15, 25

This mode is used in many open-source libraries, such as jQuery. Its $. each/$. map can be easily copied to $ (). each/$ (). map.

Another example is Backbone. Its _. each/_. map/_. every/_. chain (and many more) are copied to the Collection prototype.

The Code is as follows:

// Underscore methods that we want to implement on the Collection.
// 90% of the core usefulness of Backbone Collections is actually implemented
// Right here:
Var methods = ['foreach', 'REACH', 'map', 'Collect ', 'reduce', 'foldl ',
'Inobject', 'certificate', 'foldr ', 'Find', 'detect ', 'filter', 'select ',
'Reobject', 'every', 'all', 'some', 'any', 'include ', 'Container', 'invoke ',
'Max ', 'Min', 'toarray', 'SIZE', 'First', 'head', 'Take ', 'initial', 'Rest ',
'Tail', 'drop', 'last', 'without', 'difference ', 'indexof', 'shuffle ',
'Lastdexof ', 'isempty', 'chain'];

// Mix in each Underscore method as a proxy to 'collection # models '.
_. Each (methods, function (method ){
Collection. prototype [method] = function (){
Var args = slice. call (arguments );
Args. unshift (this. models );
Return _ [method]. apply (_, args );
};
});

Also, we copied the practical methods for object operations such as _. keys/_. values/_. pairs/_. invert/_. pick to Backbone. Model (New in 1.0)

The Code is as follows:

Var modelMethods = ['keys ', 'values', 'pairs', 'invert', 'pick', 'omit '];

// Mix in each Underscore method as a proxy to 'model # bubutes '.
_. Each (modelMethods, function (method ){
Model. prototype [method] = function (){
Var args = slice. call (arguments );
Args. unshift (this. attributes );
Return _ [method]. apply (_, args );
};
});