Qual è il modo migliore di concatenare le funzioni di Underscore.js?

Question

Underscore.js ha due modi di chiamare le funzioni, che chiamerò stile oggetto e stile di funzione. Oggetto stile è simile al seguente:

_(myObject).each(function (val, key) { 
    console.log(key, val); 
}); 

Funzione stile, d'altra parte, si presenta così:

_.each(myObject, function (val, key) { 
    console.log(key, val); 
}); 

ero felicemente utilizzando le chiamate agli oggetti in stile nel mio codice, ma ad un certo tuttavia, lo stile di chiamata dell'oggetto è scomparso dalla documentazione di underscore.js (sebbene le chiamate in stile oggetto funzionino perfettamente). Ho anche notato dei suggerimenti in giro (come nella documentazione di backbone.js) che lo stile di funzione è "migliore" o "preferito".

Quindi, lo stile di funzione è il metodo preferito? E se è così, qualcuno può spiegare il ragionamento alla base di questo?

Aggiornamento: @ggozad ha risposto parzialmente alla mia domanda. Ma sembra che la mia comprensione di come underscore.js funzioni è stata creata intorno alla versione 0.4.2. Leggendo la cronologia delle modifiche per underscore.js, si può vedere questa voce per la versione 1.2.4:

È ora possibile (e probabilmente dovrebbe) scrivere _.chain(list) invece di _(list).chain().

Mi piacerebbe sapere perché è necessario scrivere _.chain(list) anziché _(list).chain().

Answer 1

La risposta di @ggozad è in realtà molto fuorviante. Lo stile orientato agli oggetti non ha nulla a che fare con il concatenamento. L'esempio fornito:

_([1,2,3]).map(function (item) { return item * 2; }).map(function (item) { return item*3;}); 

in realtà non utilizza affatto il concatenamento di sottolineatura! Funziona solo perché l'oggetto array JS integrato ha la propria funzione map(). Prova una funzione che non è built-in (come shuffle) e vedrete si rompe:

_([1,2,3]).shuffle().shuffle(); 

L'unico modo per ottenere sottolineatura concatenamento è chiamare chain(), che si può fare utilizzando lo stile (OO o funzionale).

Per quanto riguarda il motivo per cui la documentazione dice che è necessario utilizzare _.chain, suppongo che sia solo una preferenza di stile. Ho aperto un issue at GitHub per chiarimenti.

Answer 2

Quando _ viene utilizzato come funzione, esso essenzialmente avvolge l'argomento. Il wrapper fornisce tutte le funzioni di sottolineatura normale.

La differenza che distingue lo stile è che l'uso dello stile OOP (o dello stile oggetto nella definizione) è che produce oggetti avvolti su catena. Quindi è facile da fare:

_([1,2,3]).map(function (item) { return item * 2; }).map(function (item) { return item*3;}); 

L'equivalente sarebbe:

_.map(_.map([1,2,3], function (item) { return item * 2 }), function (item) { return item * 3 }); 

che è probabilmente meno chiaro.