Primeiro, há um objeto singleton com muitos métodos de ferramentas estáticos pendurados nele. Um deles é each, que é usado para percorrer arrays ou objetos.
Copie o código do código da seguinte forma:
var nativoForEach = [].forEach
var nativoMap = [].map
varutil={
cada: função (obj, iterador, contexto) {
if (obj == nulo) retornar
if (nativeForEach && obj.forEach === nativoForEach) {
obj.forEach(iterador, contexto)
} senão if (obj.comprimento === +obj.comprimento) {
for (var i = 0; i <obj.comprimento; i++) {
if (iterator.call(obj[i] || contexto, obj[i], i, obj) === verdadeiro) retornar
}
} outro {
para (var k em obj) {
if (iterator.call(obj[k] || contexto, obj[k], k, obj) === verdadeiro) retornar
}
}
},
mapa: function(obj, iterador, contexto) {
var resultados = []
if (obj == null) retorna resultados
if (nativeMap && obj.map === nativeMap) retornar obj.map (iterador, contexto)
this.each(obj, function(val, i, col) {
resultados[i] = iterator.call(contexto, val, i, col)
})
retornar resultados
}
}
Existem também funções utilitárias como cada, algumas, etc. que operam em coleções (Array, Hash). Use o método util.xx ao usá-lo.
Se uma classe de coleção for definida, haverá dados de coleção dentro desta classe.
Copie o código do código da seguinte forma:
function Coleção(dados) {
estes.dados = dados ||
// algumas outras propriedades
// this.xxx = aaaa
}
Coleção.prototype = {
//algum método
}
Você pode copiar facilmente os métodos do util para a classe da coleção, como
Copie o código do código da seguinte forma:
function copyMethod(clazz, obj) {
for (método var em obj) {
clazz.prototype[método] = function() {
var args = [].slice.call(argumentos)
var alvo = this.data
args.unshift(alvo)
obj[método].apply(obj, args)
}
}
}
copyMethod(Coleção, utilitário)
Após copiar desta forma, a instância Collection terá o método em util, e o objeto de coleção (primeiro parâmetro) operado por util é this.data de Collection. Você pode percorrer this.data diretamente da seguinte maneira.
Copie o código do código da seguinte forma:
var coll = nova coleção([10, 20, 30])
//atravessar
col.each (função (k) {
console.log(k)
})
//operar
var arr = col.map(função(k) {
retornark-5
})
console.log(arr) // 5, 15, 25
Esse padrão é usado em muitas bibliotecas de código aberto, como jQuery, cujo $.each/$.map é convenientemente copiado para $().each/$().map.
Outro exemplo é o Backbone, cujo _.each/_.map/_.every/_.chain (e muitos mais) são copiados para o protótipo Collection.
Copie o código do código da seguinte forma:
// Métodos de sublinhado que queremos implementar na Coleção.
// 90% da utilidade central das coleções Backbone é realmente implementada
// aqui mesmo:
var métodos = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
'injetar', 'reduceRight', 'foldr', 'encontrar', 'detectar', 'filtro', 'selecionar',
'rejeitar', 'todos', 'todos', 'alguns', 'qualquer', 'incluir', 'contém', 'invocar',
'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
'cauda', 'soltar', 'último', 'sem', 'diferença', 'indexOf', 'shuffle',
'lastIndexOf', 'isEmpty', 'cadeia'];
// Misture cada método Underscore como um proxy para `Collection#models`.
_.each(métodos, função(método) {
Coleção.prototype[método] = function() {
var args = slice.call(argumentos);
args.unshift(this.models);
return _[método].apply(_, args);
};
});
Além disso, métodos práticos para operações de objetos como _.keys / _.values / _.pairs / _.invert / _.pick são copiados para Backbone.Model (novo na versão 1.0)
Copie o código do código da seguinte forma:
var modelMethods = ['chaves', 'valores', 'pares', 'inverter', 'escolher', 'omitir'];
// Misture cada método Underscore como um proxy para `Model#attributes`.
_.each(modelMethods, function(método) {
Model.prototype[método] = function() {
var args = slice.call(argumentos);
args.unshift(este.atributos);
return _[método].apply(_, args);
};
});