Lodash _(value) Method

What You’ll Learn

By the end of this tutorial, you’ll use _(value) as Lodash’s shorthand wrapper to build readable pipelines and unwrap with .value().

What Is _(value)?

_(value) is Lodash’s shorthand wrapper entry point. Call the main _ function with any value to get a sequence wrapper—the same kind of object _.chain(value) returns. Then call chainable Lodash methods one after another in a fluent pipeline.

Use _(value) when you prefer concise syntax for multi-step pipelines, when your team already reads Lodash chains fluently, or when three or more Lodash steps would otherwise nest inside each other.

📝 Syntax

The signature takes one argument—the value to wrap:

_(value)

Syntax Rules

• value — any value to wrap (array, object, number, etc.).
• Return value — a Lodash wrapper; chainable methods return another wrapper.
• Unwrap — call .value() or .valueOf() for the final result.
• Equivalent entry — _(value) and _.chain(value) start the same wrapper type.
• Not lazy — steps run when you unwrap, not as an infinite stream.

import _ from "lodash";

const data = [1, 2, 3, 4, 5];
const result = _(data)
  .map(function (x) { return x * 2; })
  .filter(function (x) { return x > 5; })
  .value();

// result -> [6, 8, 10]

Examples Gallery

Practical _(value) patterns with sample output and interactive Try It Yourself labs.

const wrappedArray = _([1, 2, 3]);

const result = wrappedArray
  .map(function (x) { return x * 2; })
  .value();

console.log(result);
// -> [2, 4, 6]

[2, 4, 6]

const data = [1, 2, 3, 4, 5];

const result = _(data)
  .map(function (x) { return x * 2; })
  .filter(function (x) { return x > 3; })
  .value();

console.log(result);
// -> [4, 6, 8, 10]

[4, 6, 8, 10]

const data = [1, 2, 3, 4, 5];

const shorthand = _(data)
  .map(function (x) { return x * 2; })
  .filter(function (x) { return x > 5; })
  .value();

const explicit = _.chain(data)
  .map(function (x) { return x * 2; })
  .filter(function (x) { return x > 5; })
  .value();

console.log(JSON.stringify(shorthand) === JSON.stringify(explicit));
// -> true

true

const user = {
  name: "Alice",
  age: 30,
  email: "alice@example.com",
  isAdmin: true
};

const publicProfile = _(user)
  .pick(["name", "age"])
  .value();

console.log(publicProfile);
// -> { name: "Alice", age: 30 }

{ name: "Alice", age: 30 }

const wrapped = _([1, 2, 3]);

const doubled = wrapped.map(function (x) { return x * 2; }).value();
const squared = wrapped.map(function (x) { return x * x; }).value();

console.log(doubled);
// -> [2, 4, 6]
console.log(squared);
// -> [1, 4, 9]

[2, 4, 6]
[1, 4, 9]

const data = [1, 2, 3];

const wrapped = _(data).map(function (x) { return x + 1; }).value();
const direct = _.map(data, function (x) { return x + 1; });

console.log(JSON.stringify(wrapped) === JSON.stringify(direct));
// -> true

// Prefer direct calls for one step; use _(value) for multi-step pipelines.

true

📝 Notes

• _(value) returns a wrapper, not transformed data—always call .value() (or .valueOf()) to finish.
• _ is dual-purpose: the Lodash namespace (_.map) and the wrapper factory (_(x)).
• _.chain(value) is the explicit equivalent—same behavior, different syntax.
• Chaining improves readability for multi-step pipelines; single-step work is often clearer as _.map(value, fn).
• For side effects between steps, use _.tap(); for custom transforms, use _.thru().
• Wrapper prototype helpers like .value() live on the object returned by _(value).

💡 Best Practices