By the end of this tutorial, you’ll use _.chain() to build readable multi-step Lodash pipelines and unwrap results with .value().
_.chain()?_.chain() wraps any value in a Lodash sequence object so you can call chainable Lodash methods one after another in a fluent, top-to-bottom pipeline. It is the explicit entry point for method chaining—the same role as the shorthand _(value).
After _.chain([1,2,3]).map(...) you still hold a wrapper. Call .value() to get the plain array, object, or number your pipeline produced.
Use it when three or more Lodash steps would otherwise nest inside each other, when you want pipeline-style readability, or when mixing Collection, Array, and Object helpers in one flow.
The signature takes one argument—the value to wrap:
_.chain(value)value — any value to wrap (array, object, number, etc.)..value() or .valueOf() for the final result.import chain from "lodash/chain";
const data = [1, 2, 3, 4, 5];
const result = chain(data)
.map(function (x) { return x * 2; })
.filter(function (x) { return x > 5; })
.value();
// result -> [6, 8, 10]| Task | Code pattern | Result |
|---|---|---|
| Start a pipeline | _.chain(array) | Lodash wrapper |
| Map then filter | _.chain(x).map(...).filter(...) | Still a wrapper |
| Get final result | ... .value() | Plain JS value |
| Shorthand wrap | _(value) | See _(value) |
| Side-effect peek | .tap(fn) | See _.tap() |
| Custom transform | .thru(fn) | See _.thru() |
WrapperUntil .value()
.value()Required finish
_(x)Same entry point
The single argument to _.chain() and what the pipeline returns:
value RequiredThe initial value wrapped in a Lodash sequence (array, object, etc.).
_.chain([1, 2, 3, 4, 5])return value WrapperA Lodash wrapper exposing chainable methods until you call .value().
_.chain(x).map(...).value() UnwrapExecutes the pipeline and returns the plain JavaScript result.
.value() // -> [6, 8, 10]chain steps MiddleAny chainable Lodash method—map, filter, sortBy, pick, groupBy, etc.
.filter(...).sortBy(...)Import the main lodash package or ensure chain-compatible method bundles are available in your build.
Practical _.chain() patterns with sample output and interactive Try It Yourself labs.
Wrap a value, chain Lodash methods, unwrap with .value().
Double each number, keep values greater than 5, then unwrap.
const data = [1, 2, 3, 4, 5];
const result = _.chain(data)
.map(function (x) { return x * 2; })
.filter(function (x) { return x > 5; })
.value();
console.log(result);
// -> [6, 8, 10]_.chain wraps the array; each method returns another wrapper until .value() runs the pipeline.
Process API-style user data in one readable pipeline.
const userData = [
{ firstName: "Ada", lastName: "Lovelace", age: 36 },
{ firstName: "Grace", lastName: "Hopper", age: 85 },
{ firstName: "Tim", lastName: "Berners-Lee", age: 16 }
];
const processed = _.chain(userData)
.filter(function (user) { return user.age >= 18; })
.sortBy("lastName")
.map(function (user) {
return {
fullName: user.firstName + " " + user.lastName,
age: user.age
};
})
.value();
console.log(processed);
// -> [{ fullName: "Ada Lovelace", age: 36 }, { fullName: "Grace Hopper", age: 85 }]Unwrapping, limiting results, aggregation, and nested-call comparison.
Without .value(), you do not get a plain array—a common beginner mistake.
const wrapped = _.chain([1, 2, 3]).map(function (n) { return n + 1; });
console.log(Array.isArray(wrapped));
// -> false
const plain = wrapped.value();
console.log(plain);
// -> [2, 3, 4]Limit output after transform steps to avoid overly long pipelines.
const data = [1, 2, 3, 4, 5];
const conciseResult = _.chain(data)
.map(function (x) { return x * 2; })
.take(3)
.value();
console.log(conciseResult);
// -> [2, 4, 6]Chain grouping and aggregation for dashboard-style summaries.
const salesData = [
{ product: "widget", quantity: 2, price: 10 },
{ product: "widget", quantity: 1, price: 10 },
{ product: "gadget", quantity: 3, price: 15 }
];
const summary = _.chain(salesData)
.groupBy("product")
.mapValues(function (products) {
return {
totalSales: _.sumBy(products, "quantity"),
averagePrice: _.meanBy(products, "price")
};
})
.value();
console.log(summary);
// widget: { totalSales: 3, averagePrice: 10 }
// gadget: { totalSales: 3, averagePrice: 15 }Chain vs nested plain Lodash calls.
Both approaches produce the same result; chaining reads top-to-bottom.
const data = [1, 2, 3, 4, 5];
const chained = _.chain(data)
.map(function (x) { return x * 2; })
.filter(function (x) { return x > 5; })
.value();
const nested = _.filter(
_.map(data, function (x) { return x * 2; }),
function (x) { return x > 5; }
);
console.log(JSON.stringify(chained) === JSON.stringify(nested));
// -> true_.chain() Works_.chain(value) stores your array, object, or primitive inside a Lodash sequence wrapper.
Each chained method (map, filter, pick, etc.) returns another wrapper with the next step recorded.
Calling .value() runs all queued operations in order and returns plain JavaScript data.
You get an array, object, or number—not a wrapper. Use _.tap() to inspect mid-chain without breaking the flow.
_.chain() returns a wrapper, not the transformed data—always call .value() (or .valueOf()) to finish._(value) is a shorthand alias for starting the same kind of sequence.reverse) may mutate the wrapped value in place; check docs for each method._.chain() turns a series of Lodash operations into a readable top-to-bottom pipeline. Wrap your data, chain the transforms you need, and unwrap with .value() to get a plain result. It shines when you have three or more sequential Lodash steps on the same value.
For the same behavior with shorter syntax, use _(value). Next in the series: the shorthand wrapper entry point and wrapper prototype helpers like .value().
.value() before passing data to other codetake, slice, or early filter to limit intermediate work_.tap() for debug logging without altering the pipeline result.value() and treat the wrapper like a plain array or object_.map() or native .filter() is enough_.chain()Use these when building fluent Lodash pipelines.
_.chain(value)
Coremap, filter, sort.
Pattern.value() required.
CriticalTop-to-bottom.
Style3+ Lodash steps.
Guideline_.chain() and _(value) start the same wrapper type—only the syntax differs. Lodash also supports implicit chaining on some methods when you use _(value) without an explicit _.chain() call, but explicit chaining makes the pipeline obvious in code reviews.
Build map/filter pipelines, process user data, and learn when to call .value().
6 people found this page helpful