Lodash Wrapper .commit() Method

What You’ll Learn

By the end of this tutorial, you’ll use wrapper .commit() to run pending chain actions eagerly, apply deferred mutations, and keep chaining without unwrapping.

What Is Wrapper .commit()?

Wrapper .commit() executes pending chain actions eagerly on the wrapped value and returns another wrapper so you can keep chaining. It is the middle ground between deferring work (default wrapper behavior) and fully unwrapping with .value().

This matters most for mutating chain steps like push() and reverse(), which may not update the original array until you commit or unwrap. Call .commit() when you need side effects applied now but still want to chain.

📝 Syntax

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

_(value).commit()
// or after queued chain steps
wrapped.push(3).commit()

Syntax Rules

• No arguments — .commit() flushes the current pending queue.
• Return — another Lodash wrapper (not plain data).
• vs .value() — .value() unwraps; .commit() keeps the chain alive.
• Mutating methods — push, reverse, etc. may defer until commit or unwrap.
• Non-mutating steps — map, filter often run at unwrap; commit forces eager execution when needed.

import _ from "lodash";

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

// array is still [1, 2] — push is deferred

wrapped.commit();
// array is now [1, 2, 3]

Examples Gallery

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

const array = [1, 2];
let wrapped = _(array).push(3);

console.log(array);
// -> [1, 2]  (unchanged — push is deferred)

wrapped = wrapped.commit();

console.log(array);
// -> [1, 2, 3]  (mutation applied)

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

const array = [1, 2];
let wrapped = _(array).push(3).commit();

const lastValue = wrapped.last();
// -> 3  (hybrid unwrap from last())

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

3
[1, 2, 3]

const array = [1, 2];

const afterCommit = _(array).push(3).commit();
// afterCommit is a wrapper — chain can continue

const afterValue = _(array).push(4).value();
// afterValue is the array [1, 2, 4] — plain, chain ended

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

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

true
true

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

let wrapped = _(numbers)
  .filter(function (n) { return n % 2 === 0; })
  .map(function (n) { return n * 10; });

const result = wrapped.commit().value();

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

[20, 40]

const items = ["a", "b", "c"];

_(items).reverse().commit();

console.log(items);
// -> ["c", "b", "a"]

["c", "b", "a"]

const users = [
  { name: "Alice", active: true },
  { name: "Bob", active: false }
];

// No mutating steps — .value() alone is enough
const names = _(users)
  .filter({ active: true })
  .map("name")
  .value();

console.log(names);
// -> ["Alice"]

// .commit() adds no benefit here unless you must flush before .value()

["Alice"]

📝 Notes

• There is no _.prototype.commit() function—the correct name is wrapper .commit() on a sequence object.
• .commit() and .value() both run pending steps; commit returns a wrapper, value returns plain data.
• Most important for mutating methods: push, pop, reverse, and similar in-place operations.
• Read-only pipelines (map, filter, pick) usually need only .value() at the end.
• Do not confuse with Git’s “commit”—this is Lodash sequence finalization, not version control.
• Next in the series: .next() advances lazy iterator-style sequences on the wrapper.

💡 Best Practices