Come si concatenano le funzioni usando lodash?

Question

Ho un oggetto che assomiglia

var foundUser = { 
    charData: [] 
} 

che poi si carica un oggetto da un database utilizzando mysql e poi chiamo

_.assignIn(foundUser, rows[0]); 

Ma ho alcune proprietà in più che io non faccio bisogno (questo non è risolvibile utilizzando select)

Così mi chiamano

foundUser = _.omit(foundUser, ['blah']); 

Ma sarebbe bello se solo potessi fare

_.assignIn(foundUser, rows[0]).omit(rows[0], ['blah']); 

Ma che getta un errore, sono io che faccio male o c'è un altro modo in cui questo può essere fatto?

Answer 1

Per catena con lodash, è necessario prima di avvolgere l'oggetto:

_(foundUser).assignIn(rows[0]).omit(['blah']).value(); 

Ulteriori chiarimenti:

Il _ crea un oggetto lodash che permette di metodo implicito concatenamento. Il concatenamento implicito del metodo significa che in alcune circostanze potrebbe restituire un valore primitivo, in altri potrebbe restituire un oggetto lodash che è necessario scartare chiamando .value() su di esso.

Se si utilizza _.chain(...), si crea un oggetto lodash con concatenamento esplicito del metodo. Il risultato è sempre un valore incartato e deve sempre essere scartato chiamando lo .value() su di esso.

Per ulteriori riferimenti Ecco i link alla documentazione:

Explicit chaining in Lodash

Implicit chaining in Lodash

Answer 2

In alternativa alla wrap-chain-unwrap modello (nulla di intrinsecamente sbagliato con esso, ma le alternative sono sempre interessante) c'è un altro modo per controllare.

Provate facendo leva su _.flow.

L'idea è che ogni funzione all'interno di flow riceverà come input l'output del precedente, che è esattamente quello che ti serve. Un esempio, dato questi dati:

var foundUser = { 
    charData: [] 
}; 

var rows = [{ok: 1, blah: 'nope'}]; 

Usando Lodash FP possiamo passare i dati come ultimo argomento. Questa caratteristica insieme alla auto-curring di ogni metodo in Lodash/fp semplifica la vita durante la composizione di funzioni.Questo significa che possiamo avere questo codice succinta ed espressivo:

_.flow(
_.assign(rows[0]), 
_.omit('blah') 
)(foundUser); 

// >> {"charData":[],"ok": 1} 

Utilizzando la versione standard di Lodash dobbiamo curry quelle funzioni a noi stessi che utilizzano _.partial, e il codice sarà certamente guardare meno laconico, ma è ancora possibile fare così:

_.flow(
_.partialRight(_.assign, rows[0]), 
_.partialRight(_.omit, 'blah') 
)(foundUser); 

// >> {"charData":[],"ok": 1} 

Un grande vantaggio di utilizzare il flusso piuttosto che concatenamento è che si può facilmente mescolare metodi Lodash con le proprie funzioni personalizzate, dal momento che - come detto - tutti hanno bisogno è ju Dati st come input e dati come output, e nient'altro:

const yourFunction = d => ({ ...d, yourProp: 4 }); 

_.flow(
_.assign(rows[0]), 
yourFunction, 
_.omit('blah') 
)(foundUser); 

// >> {"charData":[],"ok": 1, yourProp: 4} 

Questo rende composizione funzione molto più semplice e più flessibile e forse naturalmente portare a codice più espressivo.

Un'altra cosa da notare. Se si stanno installando e importando solo i metodi Lodash che si utilizzano, sarà necessario aggiungere solo il pacchetto flow e non l'intera libreria di Lodash come si farebbe con il concatenamento.

npm i --save lodash.flow 

Vs

npm i --save lodash 

Forse un vantaggio trascurabile in molte applicazioni del mondo reale in cui avere il pieno build di Lodash non è un problema e probabilmente più facile da mantenere fino ad oggi, ma molto utile nel caso in cui stai scrivendo una libreria o uno script che verrà distribuito per utilizzarlo come strumento di terze parti. In tal caso sarai in grado di mantenere il tuo ingombro molto più basso in termini di dimensioni distribuite.

Metodi Lodash docs:

• _.flow
• _.partial
• _.partialRight

Due articoli pena di verificare:

• 3 lodash functions you should be using in your Javascript
• Why chaining is a mistake

NB - il titolo del secondo articolo è un po 'dura, a mio parere, ma non saltare, il contenuto è davvero molto istruttiva.

Poche altre cose da notare:

• In Lodash/fp flusso è alias come _.pipe, in modo da poter scegliere quello che preferite.

• È anche possibile utilizzare _.flowRight (o il suo alias fp_.compose), se si preferisce diritto di composizione sinistra, come si vede in Ramda's compose.

Esempio:

_.flow(
_.assign(rows[0]), // #1st to execute 
yourFunction, // #2 
_.omit('blah'), // #3 
)(foundUser); 

// is the same as... 

_.flowRight(
_.omit('blah'), // #3rd to execute 
yourFunction, // #2 
_.assign(rows[0]), // #1 
)(foundUser); 

Answer 3

Avete mai provato lodash/fp? Viene fornito con tutte le stesse funzioni, ma sono al curry e nessuno di loro muta l'input.

Per questo motivo, è possibile comporli in un modo davvero piacevole.

Esempio:

import moment from 'moment' 
import { compose, filter, groupBy, size, sortBy } from 'lodash/fp' 

const fromAdmin = filter({ type: 'admin' }) 
const groupedByDate = groupBy(message => moment(message.createdAt).format('YYYYMMDD')) 
const sorted = sortBy('createdAt') 
const unreadByUser = filter({ isReadByUser: false }) 

const groupedMessages = compose(
    groupedByDate, 
    sorted, 
    unreadByUser, 
    fromAdmin, 
)(messages)