Lodash _.unset() Method

What You’ll Learn

By the end of this tutorial, you’ll use _.unset() to remove nested properties safely with dot paths and key arrays.

What Is _.unset()?

_.unset() is Lodash’s nested delete helper. You pass an object and a path; Lodash walks to that location and removes the property if it exists. It is the removal counterpart to _.set() and uses the same path syntax as _.get().

Use it to strip sensitive fields before API responses, remove obsolete config keys, clean dynamic object trees, and delete nested values without fragile delete obj.a.b.c chains that throw when intermediates are missing.

📝 Syntax

The signature is two arguments—object and path:

_.unset(object, path)

Syntax Rules

• object — the object to modify (mutated in place).
• path — dot string ("address.zip"), array (["profile", "temp"]), or bracket form ("users[0].email").
• Return value — true if the property existed and was removed; false otherwise.
• Missing paths — no error thrown; the object stays unchanged and you get false.
• Parent objects — remain after deletion; empty {} parents are not auto-removed.

import unset from "lodash/unset";

const user = {
  id: 1,
  name: "John",
  address: { city: "New York", zip: "10001" }
};

unset(user, "address.zip");

// user -> { id: 1, name: "John", address: { city: "New York" } }

Examples Gallery

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

const user = {
  id: 1,
  name: "John",
  address: { city: "New York", zip: "10001" }
};

_.unset(user, "address.zip");

console.log(user);
// -> { id: 1, name: "John", address: { city: "New York" } }

{ id: 1, name: "John", address: { city: "New York" } }

const data = {
  id: 1,
  name: "Alice",
  email: "alice@example.com",
  password: "hashedpassword123"
};

_.unset(data, "password");

console.log(data);
// -> { id: 1, name: "Alice", email: "alice@example.com" }

{ id: 1, name: "Alice", email: "alice@example.com" }

const nested = {
  a: { b: { c: "Nested Value" } }
};

_.unset(nested, "a.b.c");

console.log(nested);
// -> { a: { b: {} } }

{ a: { b: {} } }

const data = {
  users: [
    { name: "Alice", email: "alice@example.com" },
    { name: "Bob", email: "bob@example.com" }
  ]
};

_.unset(data, "users[0].email");

console.log(data.users[0]);
// -> { name: "Alice" }

{ name: "Alice" }

const settings = {
  theme: "dark",
  showNotifications: true,
  enableAnalytics: false
};

const pathToRemove = "showNotifications";

if (!settings.showNotifications) {
  _.unset(settings, pathToRemove);
}

console.log(settings);
// -> { theme: "dark", enableAnalytics: false }

{ theme: "dark", enableAnalytics: false }

const user = {
  name: "John",
  profile: { temp: "draft", bio: "Dev" }
};

const viaOmit = _.omit(user, ["name"]);
_.unset(user, "profile.temp");

console.log(viaOmit);
// -> { profile: { temp: "draft", bio: "Dev" } }

console.log(user);
// -> { name: "John", profile: { bio: "Dev" } }

omit: new object without name
unset: user.profile.temp removed in place

📝 Notes

• _.unset() mutates the target object—clone first when immutability matters.
• Returns true or false; it does not return the object (unlike _.set()).
• Missing paths are safe—no exception is thrown when intermediates or the final key are absent.
• Empty parent objects remain after deleting a leaf; prune them separately if needed.
• Use the same path formats as _.set() and _.get().
• For top-level key removal without mutation, prefer _.omit().

💡 Best Practices