Published on

Removing Properties from JavaScript Objects

Table of Contents

Objects are basic data structures in JavaScript that store sets of key-value pairs.

  • Keys: These act like labels or titles for each piece of information. They help you identify what data is stored.
  • Values: These are the actual data points associated with each key. They can be numbers, strings, even other objects!

Here's an example:

const car = {
  color: 'red', // Key: "color", Value: "red"
  model: 'Mustang', // Key: "model", Value: "Mustang"
  year: 1967, // Key: "year", Value: 1967
  honk: function () {
    console.log('Beep beep!')

In this example, the car object has keys like color, model, and year with their corresponding values. It also has a key named honk whose value is a function that makes the car honk.

But sometimes you might want to remove them. This article explores JavaScript's property removal methods, providing code samples and recommended practices.

Methods for Removing Properties

JavaScript offers two primary approaches for property removal:

  1. The delete Operator

    • Syntax:
    delete objectName.propertyName or delete objectName['propertyName']
    • Directly removes the specified property from the object.
    • Returns true if successful, false if the property doesn't exist or can't be deleted

    Here is an example

    const person = { name: 'Alice', age: 30 }
    delete person.age // Removes the 'age' property
    console.log(person) // Output: { name: 'Alice' }

    In this example, we delete the age property from the person object. The delete operator returns true if the deletion is successful, even if the property didn't exist before.

    We can also use bracket notation for property deletion:

    delete person['age'] // Another way to achieve the same result
    • Modifies the original object (mutative).
    • Use with caution on properties inherited from prototypes, as deletion might affect other objects in the prototype chain.
    • Cannot remove non-configurable properties (properties defined with attributes like configurable: false).
  2. Object Destructuring (Immutable Approach)

    • Syntax:
    const { unwantedProperty, ...remainingObject } = objectName
    • Preserves the original object's integrity (immutable).
    const person = { name: 'Alice', age: 30 }
    const { age, } = person // Destructure, excluding 'age'
    console.log(person) // Output: { name: 'Alice', age: 30 } (original remains unchanged)
    console.log(rest) // Output: { name: 'Alice' } (new object without 'age')

    One of the benefit Of using this approach is that it is immutable by nature meaning it creats a new object without modifying the original.


To sum up, JavaScript has two ways to remove properties from objects: The first one is object destructuring, which creates a new object without changing the original, and the delete operator, which modifies an object directly. Though the delete operator is simple, be aware of its restrictions and mutability. When keeping the original object's state is important, object destructuring is a safer option.