Comment enchaînez-vous les fonctions en utilisant lodash?

Comme alternative au Modèle wrap-chain-unwrap (rien de mal intrinsèquement, mais les alternatives sont toujours intéressantes), il existe une autre façon de vérifier.

Essayer en tirant parti de _.flow.

, L'idée est que chaque fonction à l'intérieur de flow recevra en entrée la sortie de la précédente, ce qui est exactement ce dont vous avez besoin. Un exemple, étant donné ces données:

var foundUser = {
    charData: []
};

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

En utilisant Lodash FP nous pouvons passer les données comme dernier argument. Cette caractéristique le long avec l'auto-currying de chaque méthode dans lodash / fp rend notre vie plus facile lors de la composition des fonctions. Cela signifie que nous pouvons avoir ce code succinct et expressif:

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

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

En utilisant la version standard de Lodash, nous devons curry ces fonctions nous-mêmes en utilisant _.partial, et le code sera certainement moins laconique, mais il est toujours possible de le faire:

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

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

Un grand avantage de l'utilisation de flux plutôt que de chaînage est que vous pouvez facilement mélanger Lodash méthodes avec votre propre personnalisé fonctions, depuis - comme dit - tout ce dont ils ont besoin est juste des données en entrée et des données en sortie, et rien d'autre:

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

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

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

Cela rend la composition des fonctions beaucoup plus facile et plus flexible et conduira naturellement à un code plus expressif.

Autre chose à noter. Si vous effectuez l'installation et l'importation qu'à l'Lodash les méthodes que vous utilisez, vous devrez ajouter la flow package et pas l'ensemble de la Lodash de la bibliothèque que vous souhaitez faire avec le chaînage.

npm i --save lodash.flow

Vs

npm i --save lodash

Peut - être un avantage négligeable dans de nombreuses applications du monde réel où avoir la version complète de Lodash n'est pas un problème et sans doute plus facile à maintenir à jour, mais très pratique dans le cas où vous écrivez une bibliothèque ou un script qui sera distribué à utiliser comme un outil tiers. Dans ce cas, vous serez en mesure de garder votre empreinte beaucoup plus faible en termes de taille distribuée.

Méthodes Lodash docs:

• _.flux de
• _.partiel
• _.partialRight

Deux articles à vérifier:

• 3 les fonctions lodash que vous devriez utiliser dans votre Javascript
• Pourquoi le chaînage est une erreur

NB-le titre du deuxième article est un peu dur à mon avis mais ne le sautez pas, le contenu est en effet très instructif.

Quelques autres choses à remarque:

• Dans Lodash / fp, le flux est Alias _.pipe, Vous pouvez donc choisir celui que vous préférez.

• Vous pouvez également utiliser _.flowRight (ou son alias fp _.compose) si vous préférez la composition de droite à gauche, comme on le voit dans composition de Ramda .

Exemple:

_.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);

Avez-vous déjà essayé lodash/fp? Il est livré avec toutes les mêmes fonctions, mais ils sont au curry et aucun d'entre eux ne mute l'entrée.

Pour cette raison, vous pouvez les composer d'une manière très agréable.

Exemple:

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)