Lodash _.flow() Method

Syntax, Parameter and Return Value

Syntax:

 _.flow([funcs])

Parameters:

[funcs] (...Function): The functions to invoke.

Return Value: 

(Function) - Returns the new composite function.

Examples 

Composing Functions for Data Transformation:

• JavaScript

JavaScript

var _ = require('lodash');

var square = n => n * n;

var addFive = n => n + 5;

var multiplyTwo = n => n * 2;

var transform = _.flow([square, addFive, multiplyTwo]);

console.log(transform(4));

You can also try this code with Online Javascript Compiler

Run Code

 Output:

 42 ((4^2) + 5) * 2

Demonstrates composing basic mathematical functions into a data transformation pipeline.

Creating a Text Processing Flow:

• JavaScript

JavaScript

var toUpper = text => text.toUpperCase();

var exclaim = text => text + '!';

var repeat = text => text.repeat(2);

var shout = _.flow([toUpper, exclaim, repeat]);

console.log(shout('hello')); 

You can also try this code with Online Javascript Compiler

Run Code

 Output: 

'HELLO!HELLO!'

Shows creating a sequence of string operations to process text.

Using in Data Manipulation:

• JavaScript

JavaScript

var users = [

  { 'name': 'fred', 'age': 48 },

  { 'name': 'barney', 'age': 36 }

];

var getName = user => user.name;

var toUpperName = _.flow([getName, _.toUpper]);

var upperCaseNames = _.map(users, toUpperName);

console.log(upperCaseNames);

You can also try this code with Online Javascript Compiler

Run Code

 Output:

 ['FRED', 'BARNEY']

An example of using _.flow() in conjunction with _.map() to manipulate array data.

Flow with Conditional Logic:

• JavaScript

JavaScript

var increment = n => n + 1;

var double = n => n * 2;

var conditionalDouble = n => (n % 2 === 0 ? double(n) : n);

var processNumber = _.flow([increment, conditionalDouble]);

console.log(processNumber(2));

console.log(processNumber(3)); 

You can also try this code with Online Javascript Compiler

Run Code

Output: 

6
4

Demonstrates incorporating conditional logic within a flow of functions.

Frequently Asked Questions

How is _.flow() different from chaining methods?

_.flow() composes functions into a single function that can be called later, while chaining methods involve directly calling methods one after another. _.flow() is useful for building reusable function compositions.

Can _.flow() handle asynchronous functions?

_.flow() is designed for synchronous functions. For handling asynchronous functions, you might need to use Promises or async/await patterns.

Is there a limit to the number of functions that can be composed with _.flow()?

There's no specific limit, but it's recommended to keep the number of functions reasonable for maintainability and readability.

Conclusion

Lodash's _.flow() method is a powerful tool for creating composite functions that process data through a sequence of steps. It's particularly useful for building readable and maintainable data processing pipelines and enhancing functional programming practices.

You can refer to our guided paths on the Coding Ninjas. You can check our course to learn more about DSA, DBMS, Competitive Programming, Python, Java, JavaScript, etc. 

Also, check out some of the Guided Paths on topics such as Data Structure and Algorithms, Competitive Programming, Operating Systems, Computer Networks, DBMS, System Design, etc., as well as some Contests, Test Series, and Interview Experiences curated by top Industry Experts.