Lodash _.updateWith() Method

What You’ll Learn

By the end of this tutorial, you’ll use _.updateWith() to transform nested values while controlling how missing path segments are built.

What Is _.updateWith()?

_.updateWith() combines _.update() with the customizer hook from _.setWith(). The updater transforms the value at a path; the optional customizer decides how missing intermediate containers are created while Lodash walks to that path.

Use it when you need both value transformation (increment, toggle, uppercase) and explicit control over nested structure—especially array-heavy paths like rows[0].cells[1].count.

📝 Syntax

The signature adds an optional fourth argument—the customizer:

_.updateWith(object, path, updater, [customizer])

Syntax Rules

• object — target object (mutated in place).
• path — same formats as _.update: dot string, brackets, or key array.
• updater — (currentValue) => newValue; transforms the value at the path.
• customizer — optional (nsValue, key, object) => container; creates missing intermediates only.
• Return value — the same object reference.

import updateWith from "lodash/updateWith";

const nested = {
  user: { name: "John", age: 30 }
};

updateWith(nested, "user.age", (age) => age + 1);

// nested.user.age -> 31

Examples Gallery

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

const nested = {
  user: { name: "John", age: 30 }
};

_.updateWith(nested, "user.age", (age) => age + 1);

console.log(nested.user.age);
// -> 31

31

const object = {};

_.updateWith(object, "a[0].b.count", (n) => (n || 0) + 1, Object);

console.log(object);
// -> { a: [{ b: { count: 1 } }] }

{ a: [{ b: { count: 1 } }] }

const object = {};

_.updateWith(object, "[0][1][2]", (n) => (n || 0) + 5, Array);

console.log(object[0][1][2]);
// -> 5

Value at [0][1][2]: 5

const object = {};

const customizer = (nsValue, key) => {
  if (nsValue !== undefined) return nsValue;
  return String(+key) === key ? [] : {};
};

_.updateWith(object, "rows[0].cells[1]", () => "Hello", customizer);

console.log(object.rows[0].cells[1]);
// -> "Hello"

rows[0].cells[1]: "Hello"

const config = {
  notifications: { email: { enabled: false } }
};

_.updateWith(config, "notifications.email.enabled", (v) => !v);

console.log(config.notifications.email.enabled);
// -> true

true

const user = { profile: { name: "ada" } };

_.update(user, "profile.name", (n) => n.toUpperCase());
// Same result for existing paths without customizer:

_.updateWith(user, "profile.name", (n) => n.toUpperCase());

console.log(user.profile.name);
// -> "ADA"

profile.name: "ADA"

📝 Notes

• The updater transforms the leaf value; the customizer builds intermediates only.
• Return undefined from the customizer to fall back to Lodash defaults (same as _.update).
• _.updateWith mutates the target object like _.update.
• Passing Object or Array as the customizer is a common shorthand for container creation.
• For simple transforms on existing paths, _.update() is usually enough.
• Pair conceptually with _.setWith()—updateWith adds an updater; setWith assigns a literal.

💡 Best Practices