Tout d’abord, il existe un objet singleton auquel sont attachées de nombreuses méthodes d’outils statiques. L'un d'eux est each, qui est utilisé pour parcourir des tableaux ou des objets.
Copiez le code comme suit :
var nativeForEach = [].forEach
var nativeMap = [].map
varutil = {
chacun : fonction (obj, itérateur, contexte) {
si (obj == null) retourne
if (nativeForEach && obj.forEach === nativeForEach) {
obj.forEach (itérateur, contexte)
} sinon if (obj.length === +obj.length) {
pour (var i = 0; i < obj.length; i++) {
if (iterator.call(obj[i] || context, obj[i], i, obj) === true) renvoie
}
} autre {
pour (var k dans obj) {
if (iterator.call(obj[k] || context, obj[k], k, obj) === true) renvoie
}
}
},
map : fonction (obj, itérateur, contexte) {
var résultats = []
if (obj == null) renvoie les résultats
if (nativeMap && obj.map === nativeMap) return obj.map(iterator, contexte)
this.each(obj, function(val, i, coll) {
résultats[i] = iterator.call(context, val, i, coll)
})
retourner les résultats
}
}
Il existe également des fonctions utilitaires telles que each, some, etc. qui opèrent sur des collections (Array, Hash). Utilisez la méthode util.xx lorsque vous l'utilisez.
Si une classe de collection est définie, il y a des données de collection à l'intérieur de cette classe.
Copiez le code comme suit :
fonction Collection (données) {
this.data = données ||
// quelques autres propriétés
// ceci.xxx = aaa
}
Collection.prototype = {
// une méthode
}
Vous pouvez facilement copier les méthodes de util dans la classe de collection, telles que
Copiez le code comme suit :
fonction copyMethod(clazz, obj) {
pour (méthode var dans obj) {
clazz.prototype[méthode] = fonction() {
var args = [].slice.call(arguments)
var cible = this.data
args.unshift (cible)
obj[méthode].apply(obj, arguments)
}
}
}
copyMethod (Collection, util)
Après avoir copié de cette manière, l'instance Collection aura la méthode sur util, et l'objet de collection (premier paramètre) exploité par util est this.data de Collection. Vous pouvez parcourir directement this.data comme suit.
Copiez le code comme suit :
var coll = nouvelle collection ([10, 20, 30])
// parcours
coll.each(fonction(k) {
console.log(k)
})
// opérer
var arr = coll.map(fonction(k) {
retourk-5
})
console.log(arr) // 5, 15, 25
Ce modèle est utilisé dans de nombreuses bibliothèques open source, telles que jQuery, dont $.each/$.map est facilement copié dans $().each/$().map.
Un autre exemple est Backbone, dont _.each/_.map/_.every/_.chain (et bien d'autres) sont copiés dans le prototype Collection.
Copiez le code comme suit :
// Soulignez les méthodes que nous souhaitons implémenter sur la Collection.
// 90 % de l'utilité principale de Backbone Collections est réellement implémentée
// juste ici :
var méthodes = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
'injecter', 'reduceRight', 'foldr', 'trouver', 'détecter', 'filtrer', 'sélectionner',
'rejeter', 'chaque', 'tout', 'certains', 'tout', 'inclure', 'contient', 'invoquer',
'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
'queue', 'drop', 'dernier', 'sans', 'différence', 'indexOf', 'shuffle',
'lastIndexOf', 'isEmpty', 'chaîne'];
// Mélangez chaque méthode Underscore en tant que proxy de `Collection#models`.
_.each(méthodes, fonction(méthode) {
Collection.prototype[méthode] = fonction() {
var args = tranche.call(arguments);
args.unshift(this.models);
return _[method].apply(_, args);
} ;
});
De plus, des méthodes pratiques pour faire fonctionner des objets tels que _.keys / _.values / _.pairs / _.invert / _.pick sont copiées dans Backbone.Model (nouveau dans la version 1.0)
Copiez le code comme suit :
var modelMethods = ['clés', 'valeurs', 'paires', 'inverser', 'sélectionner', 'omettre'];
// Mélangez chaque méthode Underscore en tant que proxy de `Model#attributes`.
_.each (modèleMethods, fonction (méthode) {
Modèle.prototype[méthode] = fonction() {
var args = tranche.call(arguments);
args.unshift(this.attributes);
return _[method].apply(_, args);
} ;
});