By the end of this tutorial, you’ll use wrapper .chain() to switch into explicit chaining mode and keep methods like head() wrapped until you call .value().
_(x).chain()
When unwrap happens.
Classic use case.
Entry vs mid-pipeline.
filter, map, take.
Finish with .value().
.chain()?Wrapper .chain() switches a Lodash wrapper from hybrid chaining to explicit chaining. After you call it, every subsequent method returns another wrapper until you unwrap with .value()—even methods like head() that would normally return a plain value immediately.
_.prototype.chain() or entry-point _.chain()There is no _.prototype.chain() function. Wrapper .chain() is called on an existing wrapper: _(users).chain().head().pick('user').value(). That is different from _.chain(value), which wraps a value to start a pipeline.
Use wrapper .chain() when hybrid mode would unwrap too early—for example, when you need head() followed by pick(), or any pipeline where an “exit” method should stay chainable.
Call .chain() on a wrapper with no arguments:
_(value).chain()
// or mid-pipeline on an existing wrapper
_.chain(value).chain().chain() takes nothing; it toggles explicit mode on the current wrapper..chain(), some methods auto-unwrap (head, first, last, etc.)..value() to get plain JavaScript data.import _ from "lodash";
const users = [
{ user: "barney", age: 36 },
{ user: "fred", age: 40 }
];
const firstUserName = _(users)
.chain()
.head()
.pick("user")
.value();
// firstUserName -> { user: "barney" }| Task | Code pattern | Result |
|---|---|---|
| Enable explicit mode | _(users).chain() | Wrapper (explicit) |
| head then pick | .chain().head().pick('user') | Stays wrapped |
| Without .chain() | _(users).head() | Plain object (unwraps) |
| Start explicit | _.chain(users) | See _.chain() |
| Hybrid shorthand | _(users).map(...) | See _(value) |
| Finish chain | ... .value() | Plain result |
.chain()Force wrap mode
_(value)Default unwrap
.value()Plain result
Wrapper .chain() takes no arguments and returns another wrapper in explicit mode:
(no args) RequiredCall with empty parentheses on an existing wrapper to enable explicit chaining.
_(users).chain()return (wrapper) WrapperSame wrapped value, but subsequent methods stay in wrapper mode until unwrap.
_(users).chain().head().value() result PlainAfter the full pipeline, unwrap to get a plain object, array, or primitive.
.value() // -> { user: "barney" }hybrid default Without .chain()Methods like head() unwrap immediately unless explicit mode is on.
_(users).head() // plain objectPrefer _.chain(value) when the entire pipeline should be explicit from the start.
Practical wrapper .chain() patterns with sample output and interactive Try It Yourself labs.
Enable explicit chaining with .chain(), then call methods that would otherwise unwrap.
The classic use case: get the first user, then pick one field—both steps stay wrapped.
const users = [
{ user: "barney", age: 36 },
{ user: "fred", age: 40 }
];
const result = _(users)
.chain()
.head()
.pick("user")
.value();
console.log(result);
// -> { user: "barney" }.chain() forces explicit mode so head() returns a wrapper (the first user object), letting you call .pick() on it.
In hybrid mode, head() returns a plain object—you cannot chain pick() on it.
const users = [
{ user: "barney", age: 36 },
{ user: "fred", age: 40 }
];
const hybrid = _(users).head();
// -> { user: "barney", age: 36 } (plain object, chain ended)
const explicit = _(users).chain().head().pick("user").value();
// -> { user: "barney" }
console.log(hybrid);
console.log(explicit);Multi-step pipelines, helper functions, and when to start explicit from the beginning.
Build a readable transformation pipeline with explicit chaining throughout.
const users = [
{ name: "Alice", age: 28, active: true },
{ name: "Bob", age: 17, active: true },
{ name: "Carol", age: 35, active: false },
{ name: "Dave", age: 42, active: true }
];
const names = _(users)
.chain()
.filter({ active: true })
.filter(function (u) { return u.age >= 18; })
.map("name")
.take(2)
.value();
console.log(names);
// -> ["Alice", "Dave"]Extract predicates and mappers for cleaner, testable pipeline steps.
const users = [
{ name: "Alice", age: 28 },
{ name: "Bob", age: 17 },
{ name: "Carol", age: 35 }
];
const isAdult = function (user) { return user.age >= 18; };
const adultNames = _(users)
.chain()
.filter(isAdult)
.map("name")
.value();
console.log(adultNames);
// -> ["Alice", "Carol"]Wrapper .chain() vs entry-point _.chain() and when each fits best.
Both enable explicit mode—one toggles mid-pipeline, the other starts explicit from the wrap.
const users = [
{ user: "barney", age: 36 },
{ user: "fred", age: 40 }
];
const midPipeline = _(users).chain().head().pick("user").value();
const fromStart = _.chain(users).head().pick("user").value();
console.log(JSON.stringify(midPipeline) === JSON.stringify(fromStart));
// -> trueIf the whole pipeline should be explicit, start with _.chain(value) instead of adding .chain() after _(value).
const data = [1, 2, 3, 4, 5];
// Redundant .chain() after _.chain() entry — both are explicit
const redundant = _.chain(data).chain().map(function (x) { return x * 2; }).value();
// Cleaner: _.chain() already starts explicit mode
const clean = _.chain(data).map(function (x) { return x * 2; }).value();
console.log(JSON.stringify(redundant) === JSON.stringify(clean));
// -> true.chain() WorksBegin from _(value) or any existing Lodash wrapper in hybrid mode.
.chain()Lodash re-wraps the current value and enables explicit chaining—exit methods no longer auto-unwrap.
Call head, pick, filter, etc.—each returns another wrapper until unwrap.
.value() runs the pipeline and returns plain JavaScript data—same as any other Lodash chain.
_.prototype.chain() function—the correct name is wrapper .chain() on a sequence object..chain() is not the same as entry-point _.chain(value)—different purpose, same explicit mode._(value)) auto-unwraps methods like head, first, last, and value._.chain(value) instead of adding .chain() after wrap..value() to get the final plain result in application code.Wrapper .chain() switches a Lodash wrapper into explicit chaining mode so methods like head() stay wrapped and you can keep building the pipeline. It solves the hybrid unwrap problem—especially the classic head().pick() pattern.
Next in the wrapper prototype series: .commit(), which executes pending chain actions eagerly while returning the wrapper for more steps.
.chain() when hybrid mode unwraps before you are done chaining.value() before passing results to non-Lodash code.chain() with entry-point _.chain(value)_.prototype.chain()—that name does not exist in Lodash.chain() after _.chain(value)—already explicit_(value).head() unwraps without .chain().chain()Use these when hybrid chaining unwraps too early.
_(x).chain()
CoreAuto-unwraps.
ContrastClassic pattern.
Use caseMid vs start.
Compare.value() required.
CriticalLodash has two chaining modes: hybrid (default with _(value)) and explicit (after wrapper .chain() or entry-point _.chain(value)). In hybrid mode, _(users).head() returns a plain object immediately—add .chain() first if you need to keep chaining.
Compare hybrid vs explicit chaining and build head + pick pipelines instantly.
6 people found this page helpful