Underscore.js: come funzioni personalizzate a catena

Question

Utilizzando Underscore.js, posso scrivere quanto segue, che ritorna 42:

_([42, 43]).chain() 
    .first() 
    .value() 

ho funzione personalizzata, non fa parte della Underscore.js chiamato double():

function double(value) { return value * 2; }; 

Vorrei poter chiamare questa funzione in una catena Underscore, come se fosse parte di Underscore. Vorrei scrivere la seguente, che mi piacerebbe tornare 84:

_([42, 43]).chain() 
    .first() 
    .double() 
    .value() 

Questo non può funzionare poiché sottolineatura non definisce double(). Potrei usare tap() come in:

_([42, 43]).chain() 
    .first() 
    .tap(double) 
    .value() 

Questo è valido, ma tap applica la funzione al suo argomento e restituisce l'argomento, non il risultato della funzione. Quindi mi sembra che avrei bisogno di una sorta di tap che restituisca il risultato della funzione applicata al suo argomento. C'è qualcosa di simile in Underscore.js? Mi manca qualcosa di terribilmente ovvio?

Answer 1

non trovare un tap che restituisce i rendimenti di valore dalla funzione viene eseguito, definisco una che posso take e aggiungere al _:

_.mixin({take: function(obj, interceptor) { 
    return interceptor(obj); 
}}); 

Poi assumendo che ho:

function double(value) { return value * 2; }; 

mi può scrivere:

_([42, 43]).chain() 
    .first()    // 42 
    .take(double)  // Applies double to 42 
    .value()    // 84 

È possibile guardare take come map su oggetti, anziché elenchi. Vuoi sperimentare con questo? Vedi questo example on jsFiddle.

Answer 2

in modo da avere una funzione personalizzata:

function double(value) { return value * 2; } 

È possibile utilizzare mixin per estendere la sottolineatura con esso:

_.mixin({ double:double }); 

Ora è possibile chiamare la funzione dall'oggetto Underscore _:

_.double(42); // 84 

e dall'oggetto spostato restituito da chain:

_([42, 43]).chain() 
    .first() 
    .double() // double made it onto the wrapped object too 
    .value(); // 84 

Answer 3

map funziona per questo?

_([42, 43]).chain() 
    .first() 
    .map(double) 
    .value() 

modificare

dalla documentazione, sembra che map funzionerebbe solo se lo si inserisce prima della chiamata a first:

_([42, 43]).chain() 
    .map(double) 
    .first() 
    .value() 

Answer 4

Utilizzando compose è un altro modo trattare con il situazione, ma penso che l'aggiunta di una funzione come takeas I suggested earlier è una soluzione migliore. Eppure, ecco come il codice sarà simile con compose:

function double(value) { return value * 2; }; 

_.compose(
    double, 
    _.first, 
    _.bind(_.identity, _, [42, 43]) 
)(); 

Il valore iniziale deve essere fornita attraverso una funzione che restituisce il valore (qui fatto da strigliare identity), e le funzioni devono essere elencati in un altro che è il contrario di quello che hai con una catena, che per me appare piuttosto innaturale.

Answer 5

OK, ho appena letto per la prima volta il codice sorgente sottolineato con il trattino basso. Ma penso che si può fare qualcosa di simile:

function double(value) { return value * 2; }; 

var obj = _([42, 43]).addToWrapper({double:double}); 

obj.chain() 
    .first() 
    .double() 
    .value(); 

la sintassi/dettagli potrebbero non essere di destra, ma il punto centrale è questo: quando si chiama _([42,43]), si sta chiamando sottolineare come una funzione. Quando lo fai, crea un'istanza di un nuovo oggetto e quindi mescola in quell'oggetto la maggior parte delle funzioni di sottolineatura. Quindi, restituisce quell'oggetto a te. È quindi possibile aggiungere le proprie funzioni a quell'oggetto e nulla di tutto questo inquina lo stesso spazio dei nomi "_".

Ecco come mi sembrava il codice underscore.js. Se sbaglio, mi piacerebbe scoprirlo e spero che qualcuno spiegherà perché.

EDIT: In realtà ho usato underscore.js pesantemente per circa un mese, e mi sono abbastanza familiarizzato con esso. Io ora so si comporta come ho detto qui. Quando chiami _ come funzione di Costruttore, recuperi il tuo "spazio dei nomi" (solo un oggetto), e puoi aggiungervi cose con addToWrapper() che appaiono nel tuo spazio dei nomi ma non nel "globale" "_" namespace. Quindi la funzionalità che l'OP voleva è già integrata. (E sono stato davvero impressionato dal trattino basso, btw, è molto ben fatto).

Answer 6

Nessuno ha effettivamente risposto a questo come richiesto, quindi ecco la mia risposta alla richiesta che ho testato. Si prega di leggere la nota sotto per quanto riguarda prima.

function doubleValue(x) { return x * 2; } 
var rt = _.chain([42,43]) 
     .first(1) 
     .map(doubleValue) 
     .value(); 
console.log(rt); // prints out [84] 

// Si noti che è importante dire .first() il numero di elementi che si desidera altrimenti si può ottenere un array vuoto altrimenti. Pensa prima come VOGLIO il primo numero di oggetti, quindi.prime (2) restituisce [84], [86], ecc

Answer 7

Molti modi per raggiungere facilmente questo, qui è una tale soluzione:

_.chain([42,43]) 
    .first(1) 
    .map(double) 
    .first() 
    .value(); 
    // 84 

Tuttavia, mi consiglia di utilizzare Ramda poi con auto-curry e tubi/comporre questi tipi di compiti sono banali:

R.pipe(R.head, R.multiply(2))([42, 43]); // 84 

equivalent to: 

R.compose(R.multiply(2), R.head)([42, 43]); // 84 

Se si voleva estendere la soluzione a prendere dire che i primi 2 elementi, invece di un singolo valore, come richiesto dal PO, allora:

R.pipe(R.take(2), R.map(R.multiply(2)))([42, 43]) // [84, 86] 

Tuttavia, in Ramda R.com è preferito. Ad ogni modo, per compiti banali come questo, tende ad essere più conveniente e facile da usare.

Answer 8

Sembra lodash ha implementato esattamente quello che stai cercando:

_.thru(value, interceptor) 

dalla documentazione:

Questo metodo è come _.tap eccezione del fatto che restituisce il risultato di intercettore

https://lodash.com/docs#thru