Lodash _.flowRight() Method

What You’ll Learn

By the end of this tutorial, you’ll chain small functions into one pipeline with Lodash’s _.flowRight(), running steps right to left—the same direction as mathematical compose.

What Is _.flowRight()?

_.flowRight() is Lodash’s right-to-left function composition helper. You supply two or more functions; Lodash returns a new function that runs the rightmost function first, then pipes each result to the function on its left. It matches how mathematicians write compose: outer function on the left, inner on the right.

If you already use a manual compose(f, g) helper, _.flowRight(f, g) does the same thing with Lodash’s variadic or array syntax—no custom utility required.

📝 Syntax

Pass functions as variadic arguments or inside one array:

_.flowRight([funcs])

// or

_.flowRight(funcs)

Syntax Rules

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

import flowRight from "lodash/flowRight";



const addFive = (x) => x + 5;

const double = (x) => x * 2;

const square = (x) => x * x;



const composed = flowRight(addFive, double, square);



composed(3);

// square(3) -> 9, double(9) -> 18, addFive(18) -> 23

Examples Gallery

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

const addFive = (x) => x + 5;

const double = (x) => x * 2;

const square = (x) => x * x;



const composed = _.flowRight(addFive, double, square);



console.log(composed(3));

// square(3)=9, double(9)=18, addFive(18)=23

23

const add = (x) => x + 5;

const multiply = (x) => x * 2;



const compose = (f, g) => (x) => f(g(x));



const viaFlowRight = _.flowRight(add, multiply);

const viaCompose = compose(add, multiply);



console.log(viaFlowRight(10)); // add(multiply(10)) = 25

console.log(viaCompose(10));   // 25

25

25

const trim = (str) => str.trim();

const toLower = (str) => str.toLowerCase();

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



// Order in call: outer steps on the left, inner on the right

const toSlug = _.flowRight(trim, toLower, removeSpaces);



const input = "   Hello World   ";

console.log(toSlug(input)); // "helloworld"

helloworld

const f = (x) => x + 2;

const g = (x) => x * 3;

const h = (x) => x - 1;



const composed = _.flowRight(f, g, h);

const nested = (x) => f(g(h(x)));



console.log(composed(4));  // f(g(h(4))) = f(9) = 11

console.log(nested(4));    // 11

11

11

const f = (x) => x + 1;

const g = (x) => x * 2;

const h = (x) => x - 1;



console.log(_.flowRight(f, g, h)(5));

// h(5)=4, g(4)=8, f(8)=9  — right to left



console.log(_.flow(f, g, h)(5));

// f(5)=6, g(6)=12, h(12)=11 — left to right

9

11

const inc = (x) => x + 1;

const double = (x) => x * 2;

const dec = (x) => x - 3;



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



console.log(transform(5));

// inc(5)=6, double(6)=12, dec(12)=9

9

📝 Notes

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

💡 Best Practices