Erstens gibt es ein Singleton-Objekt, an dem viele statische Werkzeugmethoden hängen. Einer davon ist jeder, der zum Durchlaufen von Arrays oder Objekten verwendet wird.
Kopieren Sie den Codecode wie folgt:
var nativeForEach = [].forEach
var nativeMap = [].map
varutil = {
Each: Funktion (Objekt, Iterator, Kontext) {
if (obj == null) zurückgeben
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
}
} anders {
for (var k in obj) {
if (iterator.call(obj[k] || context, obj[k], k, obj) === true) zurückgeben
}
}
},
map: function(obj, iterator, context) {
var-Ergebnisse = []
if (obj == null) gibt Ergebnisse zurück
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)
})
Ergebnisse zurückgeben
}
}
Es gibt auch Hilfsfunktionen wie „Every“, „Some“ usw., die auf Sammlungen (Array, Hash) angewendet werden. Verwenden Sie bei der Verwendung die Methode util.xx.
Wenn eine Sammlungsklasse definiert ist, befinden sich in dieser Klasse Sammlungsdaten.
Kopieren Sie den Codecode wie folgt:
Funktion Sammlung(Daten) {
this.data = Daten ||.
// einige andere Eigenschaften
// this.xxx = yyy
}
Collection.prototype = {
// irgendeine Methode
}
Sie können die Methoden von util einfach in die Collection-Klasse kopieren, z
Kopieren Sie den Codecode wie folgt:
Funktion copyMethod(clazz, obj) {
for (var-Methode in obj) {
clazz.prototype[method] = function() {
var args = [].slice.call(arguments)
var target = this.data
args.unshift(Ziel)
obj[Methode].apply(obj, args)
}
}
}
copyMethod(Collection, util)
Nach dem Kopieren auf diese Weise verfügt die Collection-Instanz über die Methode von util, und das von util betriebene Collection-Objekt (erster Parameter) ist this.data der Collection. Sie können this.data wie folgt direkt durchlaufen.
Kopieren Sie den Codecode wie folgt:
var coll = neue Sammlung([10, 20, 30])
// durchqueren
coll.each(function(k) {
console.log(k)
})
// operieren
var arr = coll.map(function(k) {
returnk-5
})
console.log(arr) // 5, 15, 25
Dieses Muster wird in vielen Open-Source-Bibliotheken verwendet, beispielsweise in jQuery, deren $.each/$.map praktischerweise nach $().each/$().map kopiert wird.
Ein weiteres Beispiel ist Backbone, dessen _.each/_.map/_.every/_.chain (und viele weitere) in den Collection-Prototyp kopiert werden.
Kopieren Sie den Codecode wie folgt:
// Unterstreichungsmethoden, die wir in der Sammlung implementieren möchten.
// 90 % des Kernnutzens von Backbone Collections sind tatsächlich implementiert
// genau hier:
var-Methoden = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
'ablehnen', 'jeder', 'alle', 'einige', 'beliebig', 'einschließen', 'enthält', 'aufrufen',
'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',
'lastIndexOf', 'isEmpty', 'chain'];
// Jede Underscore-Methode als Proxy für „Collection#models“ einmischen.
_.each(Methoden, Funktion(Methode) {
Collection.prototype[method] = function() {
var args = Slice.call(Argumente);
args.unshift(this.models);
return _[Methode].apply(_, args);
};
});
Darüber hinaus werden praktische Methoden für Objektoperationen wie _.keys / _.values / _.pairs / _.invert / _.pick nach Backbone.Model kopiert (neu in 1.0)
Kopieren Sie den Codecode wie folgt:
var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];
// Mischen Sie jede Underscore-Methode als Proxy für „Model#attributes“.
_.each(modelMethods, function(method) {
Model.prototype[Methode] = function() {
var args = Slice.call(arguments);
args.unshift(this.attributes);
return _[Methode].apply(_, args);
};
});