JavaScript Reflect.deleteProperty() Method

Beginner
5 min read
Updated: Nov 2026
3 examples
Static method

Definition

Reflect.deleteProperty(target, propertyKey) removes a property from an object. It is the function version of the delete operator: Reflect.deleteProperty(obj, "a") does the same as delete obj.a.

It returns true when the property is gone after the call, and false when it could not be removed, for example because it is not configurable. It never throws for that, even in strict mode, where the delete operator would.

Remember
Reflect.deleteProperty(target, key)

removed, or was never there  → true
cannot be removed            → false (no error)

Same as:  delete target[key]
target must be an object, or TypeError

Syntax

Pass an object and the name of the property to remove.

JavaScript
const user = { name: "Ann", age: 30 };

console.log(Reflect.deleteProperty(user, "age"));   // true
console.log("age" in user);                         // false
console.log(Reflect.deleteProperty(user, "city"));  // true (it was not there)
CallWhat it does
Reflect.deleteProperty(obj, "a")Remove the property a. Returns true if it is gone.
Reflect.deleteProperty(arr, 1)Remove an array item. It leaves an empty slot and keeps the length.
delete obj.aThe operator. In strict mode it throws a TypeError when removal fails.
Reflect.has(obj, "a")Check if the property is still there.

A standard JavaScript static method (ES2015) of the Reflect object: call it as Reflect.deleteProperty(). No import required. Siblings: Reflect.apply(), Reflect.construct(), Reflect.defineProperty(), Reflect.get(), Reflect.getOwnPropertyDescriptor(), Reflect.getPrototypeOf(), Reflect.has(), Reflect.isExtensible(), Reflect.ownKeys(), Reflect.preventExtensions(), Reflect.set(), Reflect.setPrototypeOf().

Library declarations
JavaScript
// ECMAScript 2015 (ES6)
Reflect.deleteProperty(target, propertyKey)

// target      : an object
// propertyKey : a string or a symbol
// returns     : true or false
// throws      : TypeError if target is not an object

Parameters

ParameterDescription
targetRequired. The object to change. If it is not an object, a TypeError is thrown.
propertyKeyRequired. The name of the property to remove: a string or a symbol.

Return Value

Return ValueDescription
trueThe property was removed, or it did not exist in the first place.
falseThe property exists but cannot be removed, because it is not configurable (for example on a frozen or sealed object).
TypeError (thrown)target is not an object.

JavaScript Examples

Example 1 — Remove a Property

Remove a property, remove it again, and remove one that never existed.

JavaScript
const user = { name: "Ann", age: 30 };

console.log("Delete age: " + Reflect.deleteProperty(user, "age"));
console.log("Still has age: " + Reflect.has(user, "age"));
console.log("Delete age again: " + Reflect.deleteProperty(user, "age"));
console.log("Delete city: " + Reflect.deleteProperty(user, "city"));
console.log("Keys left: " + Object.keys(user).join(", "));
Try It Yourself

How It Works

  1. Remove it. The property age exists and can be removed, so the call returns true and Reflect.has() then says false.
  2. Missing is fine. Deleting age again, or deleting city that was never there, also returns true, because there is nothing left to remove.
  3. Check what remains. Only name is left in the object.

Example 2 — Properties That Cannot Be Removed

A property that is not configurable stays. See the result for a frozen object and for a property made with defineProperty(). The function with "use strict" shows how the operator reacts.

JavaScript
const frozen = Object.freeze({ a: 1 });
console.log("Frozen object: " + Reflect.deleteProperty(frozen, "a"));

const obj = {};
Object.defineProperty(obj, "id", { value: 1 });
console.log("Locked property: " + Reflect.deleteProperty(obj, "id"));
console.log("id is still: " + obj.id);

function strictDelete(o) {
  "use strict";
  delete o.id;
}

try {
  strictDelete(obj);
} catch (err) {
  console.log("Strict delete: " + err.name);
}
Try It Yourself

How It Works

  1. Frozen. Object.freeze() makes every property not configurable, so Reflect.deleteProperty() returns false.
  2. Locked by default. A property made with defineProperty() and no flags is not configurable, so it stays and obj.id is still 1.
  3. The operator is stricter. Inside a function with "use strict", delete o.id throws a TypeError. Reflect.deleteProperty() only returns false.

Example 3 — Arrays and Inherited Properties

Remove an array item, and try to remove a property that lives on the prototype.

JavaScript
const letters = ["a", "b", "c"];
console.log("Delete item 1: " + Reflect.deleteProperty(letters, 1));
console.log("Length stays: " + letters.length);
console.log("Item 1 exists: " + (1 in letters));

const parent = { shared: "yes" };
const child = Object.create(parent);

console.log("Delete inherited: " + Reflect.deleteProperty(child, "shared"));
console.log("Still readable: " + child.shared);
Try It Yourself

How It Works

  1. Array items. Removing item 1 leaves an empty slot. The length is still 3, and 1 in letters is false. To close the gap, use splice() instead.
  2. Own properties only. child has no own property called shared, so there is nothing to remove from it, and the call returns true.
  3. The prototype is untouched. child.shared is still readable, because the value comes from parent.

Browser & Runtime Support

Reflect.deleteProperty() is part of ES2015 (ES6), together with the Reflect object. Every current browser and Node.js has it.

✓ ES2015 · Widely supported

Reflect.deleteProperty()

Supported in Chrome 49+, Edge 12+, Firefox 42+, Safari 10+, Opera 36+ and Node.js 6+. Internet Explorer never got it.

ES2015 Standard since
Google Chrome 49+ · Desktop & Mobile
Full support
Microsoft Edge 12+ · Chromium and legacy
Full support
Mozilla Firefox 42+ · Desktop & Mobile
Full support
Apple Safari 10+ · macOS & iOS
Full support
Opera 36+ · Chromium based
Full support
Samsung Internet Recent versions · Android
Supported
Android WebView 49+ · Chromium based
Supported
Node.js 6+ · Server runtime
Supported
Deno Supported · JavaScript runtime
Supported
Bun Supported · JavaScript runtime
Supported
Internet Explorer No native support
Not supported
Reflect.deleteProperty() Excellent

Bottom line: Safe to use in every current browser and in Node.js. The only thing to plan for is Internet Explorer, which has no Reflect at all.

Frequently Asked Questions

It removes a property from an object and returns true if the property is gone, or false if it could not be removed. It is the function version of the delete operator.
They remove the same properties. The difference is in strict mode: delete throws a TypeError when the property cannot be removed, while Reflect.deleteProperty() returns false. Also, Reflect.deleteProperty() is a function that you can pass around.
Because the goal is reached: after the call the property is not in the object. true means "it is gone", not "something was removed". Use Reflect.has() first if you need to know.
When the property exists but is not configurable. This is the case for properties of frozen or sealed objects, and for properties created with defineProperty() without configurable: true.
Reflect.deleteProperty(array, index) leaves an empty slot and does not change the length. To remove the item and close the gap, use splice(index, 1) instead.

Next: Reflect.get()

Learn how to read a property from an object as a function call, including getters and the receiver.

Reflect.get() tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

10 people found this page helpful