Lodash Wrapper .value() Method

What You’ll Learn

By the end of this tutorial, you’ll use wrapper .value() to finish Lodash chains and get plain JavaScript data your app can use.

What Is Wrapper .value()?

Wrapper .value() is how you unwrap a Lodash chain and get plain JavaScript data back. After building a pipeline with _(data), .map(), .filter(), and other steps, .value() runs the queued actions and returns the final result—usually an array or object, not a wrapper.

Think of .value() as the exit door from Lodash chaining. Every transform method before it queues work; .value() executes that work and hands you the outcome. It also flushes deferred mutations from methods like push and .reverse().

📝 Syntax

Call .value() on a wrapper with no arguments:

const wrapped = _([1, 2, 3]);
const plain = wrapped.value();
// plain -> [1, 2, 3] (plain array)

Syntax Rules

• No arguments — .value() takes nothing; it unwraps whatever the chain produced.
• Returns plain data — an array, object, number, string, etc.—not a Lodash wrapper.
• End of chain — call it when you are done chaining and need the final result.
• Eager execution — runs all queued lazy steps and deferred mutations at once.
• Works with _.chain() — explicit chains also finish with .value().

import _ from "lodash";

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

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

Examples Gallery

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

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

console.log(unwrappedArray);
// -> [1, 2, 3]

console.log(typeof wrappedArray.value === "function");
// -> false on unwrappedArray (it's a plain array)

[1, 2, 3]
false

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

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

[4, 6, 8]

const arr1 = [1, 2];
const arr2 = [1, 2];

const afterCommit = _(arr1).push(3).commit();
const afterValue = _(arr2).push(4).value();

console.log(typeof afterCommit.value === "function");
// -> true (still a wrapper)

console.log(Array.isArray(afterValue));
// -> true (plain array)

true
true

const result = _.chain([1, 2, 3, 4, 5])
  .filter(function (n) { return n % 2 === 0; })
  .map(function (n) { return n * 10; })
  .value();

console.log(result);
// -> [20, 40]

[20, 40]

const array = [1, 2];
const result = _(array).push(3).value();

console.log(result);
// -> [1, 2, 3]

console.log(array);
// -> [1, 2, 3] (mutated on unwrap)

[1, 2, 3]
[1, 2, 3]

const wrapped = _([1, 2, 3]).map(function (n) { return n + 1; });
const plain = wrapped.value();

console.log(typeof wrapped.value === "function");
// -> true (still a wrapper)

console.log(Array.isArray(plain));
// -> true (plain array ready to use)

true
true

📝 Notes

• There is no _.prototype.value() function—the correct name is wrapper .value() on a sequence object.
• Always call .value() at the end of explicit _.chain() pipelines—otherwise you still hold a wrapper.
• .value() is terminal: it returns plain data, not another chainable wrapper.
• Use .commit() instead when you need to flush mutations but keep chaining.
• For step-by-step lazy consumption, see .next() instead of bulk .value().
• Next in the series: _.tap() for side effects inside chains without changing the value.

💡 Best Practices