Lodash _.flow() Method

What You’ll Learn

By the end of this tutorial, you’ll chain small functions into one pipeline with Lodash’s _.flow(), running steps left to right.

What Is _.flow()?

_.flow() is a Lodash util helper for function composition. You supply two or more functions; Lodash returns a new function that runs them in sequence. The return value of step one becomes the input to step two, and so on— like a conveyor belt moving data through transforms.

Composition keeps each step small and testable. Instead of one long function with ten lines of logic, you name each step and wire them with _.flow().

📝 Syntax

Pass functions as variadic arguments or inside one array:

_.flow([funcs])
// or
_.flow(funcs)

Syntax Rules

• funcs — one or more functions, or a single array of functions.
• Order — left to right: first listed function runs first.
• Return value — a new composed function you call later.
• First call — all arguments go to the first function only.
• Later steps — each receives one value (previous return).

import flow from "lodash/flow";

const double = (x) => x * 2;
const square = (x) => x * x;
const subtractTen = (x) => x - 10;

const pipeline = flow(double, square, subtractTen);

pipeline(5);
// double(5) -> 10, square(10) -> 100, subtractTen(100) -> 90

Examples Gallery

Practical _.flow() patterns with copy-ready code, sample output, and interactive Try It Yourself labs.

const double = (x) => x * 2;
const square = (x) => x * x;
const subtractTen = (x) => x - 10;

const pipeline = _.flow(double, square, subtractTen);

console.log(pipeline(5));
// 5 -> 10 -> 100 -> 90

90

const trim = (str) => str.trim();
const toLower = (str) => str.toLowerCase();
const removeSpaces = (str) => str.replace(/\s+/g, "");

const normalize = _.flow(trim, toLower, removeSpaces);

const input = "   Hello World   ";
console.log(normalize(input)); // "helloworld"

helloworld

const parseJSON = (json) => JSON.parse(json);
const keepPositive = (arr) => arr.filter((n) => n > 0);
const average = (arr) =>
  arr.reduce((sum, n) => sum + n, 0) / arr.length;

const statsFromJson = _.flow(parseJSON, keepPositive, average);

console.log(statsFromJson("[1, 2, 3, -4, 5]"));
// (1 + 2 + 3 + 5) / 4 = 2.75

2.75

const inc = (x) => x + 1;
const double = (x) => x * 2;
const dec = (x) => x - 3;

const transform = _.flow(inc, double, dec);

console.log(transform(5));
// inc(5)=6, double(6)=12, dec(12)=9

9

const f = (x) => x + 2;
const g = (x) => x * 3;
const h = (x) => x - 1;

const piped = _.flow(f, g, h);
const nested = (x) => h(g(f(x)));

console.log(piped(4));  // h(g(f(4))) = h(18) = 17
console.log(nested(4)); // 17

17
17

const f = (x) => x + 1;
const g = (x) => x * 2;
const h = (x) => x - 1;

console.log(_.flow(f, g, h)(5));
// f(5)=6, g(6)=12, h(12)=11  — left to right

console.log(_.flowRight(f, g, h)(5));
// h(5)=4, g(4)=8, f(8)=9   — right to left

11
9

📝 Notes

• Only the first function receives multiple arguments from pipeline(a, b).
• Steps after the first should be unary—one input, one output.
• Order matters: _.flow(f, g) is not the same as _.flow(g, f).
• _.flow() is for composing return-value functions—not Express (req, res, next) middleware.
• Handle errors in individual steps; flow does not add try/catch between steps.
• Next in the series: _.flowRight() for right-to-left composition.

💡 Best Practices