Lodash flow、get、find组合执行步骤详解（附示例参数）

Alright, let's break down this functional programming code step by step, using the context you provided. I'll assume we're working with Ramda.js here since flow, find, and get are core functions from that library (the most common implementation for this pattern).

First, let's recap the given context to keep things grounded:

• args.roleRateId = 11604
• args.roleRates is an array like [{ id:1 , chargeRate: 200}, { id:2 ,chargeRate: 250}]

1. Understand what flow() does #

flow is a function composition tool. It takes a list of functions as inputs and spits out a single, combined function. When you call this combined function with a value, it passes that value through each of the original functions in order: the output of the first function becomes the input of the second, and so on. The final result is whatever the last function returns.

Think of it like a assembly line: your raw array goes through the first "machine" (find), then the output moves to the second machine (get), and you get your final product at the end.

2. Unpack the first function in the flow: find({ id: args.roleRateId }) #

Ramda's find is a curried function — meaning we can pre-set some of its arguments before giving it the final input. Here's what's happening:

• We're pre-configuring find with a matching rule: { id: 11604 }. Ramda treats this object as a "match check" — it will hunt for the first item in the array where the id property exactly equals 11604.
• Right now, this find call is just waiting for an array to process. It's a partially set-up function, ready to receive args.roleRates later.

When it finally gets the array:

• It loops through every object in args.roleRates.
• It checks if any object has an id of 11604.
• If it finds a match, it returns that entire object (e.g., if your array had { id:11604, chargeRate: 300 }, that's what you'd get). If no match exists, it returns undefined.

3. Unpack the second function in the flow: get('chargeRate') #

Ramda's get is also curried. We've pre-set it to look for the chargeRate property. Like find, it's waiting for an input — specifically, an object (or undefined).

When it receives the output from the find step:

• If the input is a valid object (e.g., { id:11604, chargeRate: 300 }), it pulls out the chargeRate value and returns it (300 in this case).
• If the input is undefined (because find didn't find a matching object), get safely returns undefined instead of throwing an error — this is one of Ramda's handy features for handling missing data gracefully.

4. Run the composed function with args.roleRates #

When you execute flow(find(...), get(...))(args.roleRates), here's the full play-by-play:

1. args.roleRates is passed to the pre-configured find function.
2. find searches the array for the first object with id:11604 and returns that object (or undefined).
3. That result is immediately sent to the pre-configured get function.
4. get extracts the chargeRate value from the object (or returns undefined if no object was found).

Example scenario #

Suppose args.roleRates looked like this:

[
  { id:1 , chargeRate: 200},
  { id:11604 ,chargeRate: 350},
  { id:2 ,chargeRate: 250}
]

The execution would go:

• find returns { id:11604 ,chargeRate: 350 }
• get('chargeRate') takes that object and returns 350
• The final result of the entire expression is 350

If args.roleRates had no object with id:11604, the result would be undefined.

内容的提问来源于stack exchange，提问作者Chris D