Lodash Wrapper Prototype Methods

What You’ll Learn

By the end of this guide, you’ll know which wrapper prototype methods finish, extend, or clone a Lodash chain—and when to use each.

What Is the Wrapper Prototype?

When you call _.chain(value) or _(value), Lodash returns a wrapper object—not plain data. That wrapper exposes chainable Lodash methods (map, filter, etc.) and special prototype methods that control the pipeline itself: .value(), .commit(), .plant(), and others.

Think of wrapper prototype methods as the steering wheel of a chain: collection helpers move the data; prototype helpers decide when to unwrap, re-run, clone, or iterate the wrapper itself.

📝 Syntax

Prototype methods are called on the wrapper returned by a chain entry point:

_(value)
  .map(/* ... */)
  .filter(/* ... */)
  .value();   // unwrap — most common finish

// Other prototype methods:
.commit();   // run pending steps, return wrapper
.plant(newValue);
.next();
.reverse();

Syntax Rules

• Call on wrapper — prototype methods are .value() style, not _.value() namespace calls.
• .value() / .valueOf() — aliases; both unwrap and return plain JavaScript data.
• .commit() — executes queued actions but returns another wrapper for hybrid chaining.
• .plant(value) — clones the chain state with a different wrapped value.
• Chain first — start with _(value) or _.chain(value), then call collection methods, then a prototype method.

import _ from "lodash";

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

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

Examples Gallery

Practical wrapper prototype patterns with sample output and interactive Try It Yourself labs.

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

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

[6, 8, 10]

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

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

console.log(JSON.stringify(viaValue) === JSON.stringify(viaValueOf));
// -> true

true

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

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

[6, 8, 10]

const template = _([1, 2, 3]).map(function (x) { return x * 2; });

const fromFirst = template.value();
// -> [2, 4, 6]

const fromSecond = template.plant([10, 20]).value();
// -> [20, 40]

[2, 4, 6]
[20, 40]

const data = [1, 2, 3];

const reversed = _(data)
  .reverse()
  .value();

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

[3, 2, 1]

📝 Notes

• There is no _.prototype() function—prototype methods are called on the wrapper (.value(), not _.value()).
• .value() and .valueOf() are aliases—both unwrap the chain.
• .commit() is rarely needed in everyday code; reach for it when mixing wrapper and plain Lodash in one pipeline.
• .reverse() mutates the wrapped array in place, like native Array.prototype.reverse.
• .next() is for iterator-style lazy sequences—most beginners only need .value().
• Deep dives live at /lodash/seq/prototype/value, .../commit, etc.

💡 Best Practices