let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*",

我应该如何删除属性 regex 以得到新的 myObject 如下?

let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",

To remove a property from an object (mutating the object), you can do it like this:

delete myObject.regex;
// or,
delete myObject['regex'];
// or,
var prop = "regex";
delete myObject[prop];


var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
delete myObject.regex;


For anyone interested in reading more about it, Stack Overflow user kangax has written an incredibly in-depth blog post about the delete statement on their blog, Understanding delete. It is highly recommended.

If you'd like a new object with all the keys of the original except some, you could use the destructuring.


let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"

const {regex, …newObj} = myObject;

console.log(newObj); // has no ‘regex’ key
console.log(myObject); // remains unchanged


Old question, modern answer. Using object destructuring, an ECMAScript 6 feature, it's as simple as:

const { a, } = { a: 1, b: 2, c: 3 };

Or with the questions sample:

const myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
const { regex, ...newObject } = myObject;

You can see it in action in the Babel try-out editor.


To reassign to the same variable, use a let:

let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);

Spread Syntax (ES6)

To complete Koen's answer, in case you want to remove a dynamic variable using the spread syntax, you can do it like so:

const key = 'a';

const { [key]: foo, …rest } = { a: 1, b: 2, c: 3 };

console.log(foo); // 1
console.log(rest); // { b: 2, c: 3 }

* foo will be a new variable with the value of a (which is 1).

Extended answer 😇

There are a few common ways to remove a property from an object.
Each one has its own pros and cons (check this performance comparison):

Delete Operator

It is readable and short, however, it might not be the best choice if you are operating on a large number of objects as its performance is not optimized.

delete obj[key];


It is more than two times faster than delete, however the property is not deleted and can be iterated.

obj[key] = null;
obj[key] = false;
obj[key] = undefined;

Spread Operator

This ES6 operator allows us to return a brand new object, excluding any properties, without mutating the existing object. The downside is that it has the worse performance out of the above and is not suggested to be used when you need to remove many properties at a time.

{ [key]: val, } = obj;

Another alternative is to use the Underscore.js library.

Note that _.pick() and _.omit() both return a copy of the object and don't directly modify the original object. Assigning the result to the original object should do the trick (not shown).

Reference: link _.pick(object, *keys)

Return a copy of the object, filtered to only have values for the whitelisted keys (or array of valid keys).

var myJSONObject = 
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

_.pick(myJSONObject, “ircEvent”, “method”);
=> {“ircEvent”: “PRIVMSG”, “method”: “newURI”};

Reference: link _.omit(object, *keys)

Return a copy of the object, filtered to omit the blacklisted keys (or array of keys).

var myJSONObject = 
{"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

_.omit(myJSONObject, “regex”);
=> {“ircEvent”: “PRIVMSG”, “method”: “newURI”};

For arrays, _.filter() and _.reject() can be used in a similar manner.

ECMAScript 2015 (or ES6) came with built-in Reflect object. It is possible to delete object property by calling Reflect.deleteProperty() function with target object and property key as parameters:

Reflect.deleteProperty(myJSONObject, 'regex');

which is equivalent to:

delete myJSONObject['regex'];

But if the property of the object is not configurable it cannot be deleted neither with deleteProperty function nor delete operator:

let obj = Object.freeze({ prop: "value" });
let success = Reflect.deleteProperty(obj, "prop");
console.log(success); // false
console.log(obj.prop); // value

Object.freeze() makes all properties of object not configurable (besides other things). deleteProperty function (as well as delete operator) returns false when tries to delete any of it's properties. If property is configurable it returns true, even if property does not exist.

The difference between delete and deleteProperty is when using strict mode:

"use strict";

let obj = Object.freeze({ prop: “value” });
Reflect.deleteProperty(obj, “prop”); // false
delete obj[“prop”];
// TypeError: property “prop” is non-configurable and can’t be deleted


Suppose you have an object that looks like this:

var Hogwarts = {
    staff : [
        'Argus Filch',
        'Filius Flitwick',
        'Gilderoy Lockhart',
        'Minerva McGonagall',
        'Poppy Pomfrey',
    students : [
        'Hannah Abbott',
        'Katie Bell',
        'Susan Bones',
        'Terry Boot',
        'Lavender Brown',

Deleting an object property

If you want to use the entire staff array, the proper way to do this, would be to do this:

delete Hogwarts.staff;

Alternatively, you could also do this:

delete Hogwarts['staff'];

Similarly, removing the entire students array would be done by calling delete Hogwarts.students; or delete Hogwarts['students'];.

Deleting an array index

Now, if you want to remove a single staff member or student, the procedure is a bit different, because both properties are arrays themselves.

If you know the index of your staff member, you could simply do this:

Hogwarts.staff.splice(3, 1);

If you do not know the index, you'll also have to do an index search:

Hogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva McGonnagall') - 1, 1);


While you technically can use delete for an array, using it would result in getting incorrect results when calling for example Hogwarts.staff.length later on. In other words, delete would remove the element, but it wouldn't update the value of length property. Using delete would also mess up your indexing.

So, when deleting values from an object, always first consider whether you're dealing with object properties or whether you're dealing with array values, and choose the appropriate strategy based on that.

If you want to experiment with this, you can use this Fiddle as a starting point.

Using delete method is the best way to do that, as per MDN description, the delete operator removes a property from an object. So you can simply write:

delete myObject.regex;
// OR
delete myObject['regex'];

The delete operator removes a given property from an object. On successful deletion, it will return true, else false will be returned. However, it is important to consider the following scenarios:

  • If the property which you are trying to delete does not exist, delete will not have any effect and will return true

  • If a property with the same name exists on the object's prototype chain, then, after deletion, the object will use the property from the prototype chain (in other words, delete only has an effect on own properties).

  • Any property declared with var cannot be deleted from the global scope or from a function's scope.

  • As such, delete cannot delete any functions in the global scope (whether this is part from a function definition or a function (expression).

  • Functions which are part of an object (apart from the
    global scope) can be deleted with delete.

  • Any property declared with let or const cannot be deleted from the scope within which they were defined. Non-configurable properties cannot be removed. This includes properties of built-in objects like Math, Array, Object and properties that are created as non-configurable with methods like Object.defineProperty().

The following snippet gives another simple example:

var Employee = {
      age: 28,
      name: 'Alireza',
      designation: 'developer'
console.log(delete;   // returns true
console.log(delete Employee.age);    // returns true

// When trying to delete a property that does
// not exist, true is returned
console.log(delete Employee.salary); // returns true</code></pre>

For more info about and seeing more example, visit the link below:

Another solution, using Array#reduce.

var myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"

myObject = Object.keys(myObject).reduce(function(obj, key) {
if (key != “regex”) { //key you want to remove
obj[key] = myObject[key];
return obj;
}, {});


However, it will mutate the original object. If you want to create a new object without the specified key, just assign the reduce function to a new variable, e.g.:


const myObject = {
  ircEvent: 'PRIVMSG',
  method: 'newURI',
  regex: '^http://.*',

const myNewObject = Object.keys(myObject).reduce((obj, key) => {
key !== ‘regex’ ? obj[key] = myObject[key] : null;
return obj;
}, {});



There are a lot of good answers here but I just want to chime in that when using delete to remove a property in JavaScript, it is often wise to first check if that property exists to prevent errors.


var obj = {"property":"value", "property2":"value"};

if (obj && obj.hasOwnProperty(“property2”)) {
delete obj.property2;
} else {
//error handling

Due to the dynamic nature of JavaScript there are often cases where you simply don't know if the property exists or not. Checking if obj exists before the && also makes sure you don't throw an error due to calling the hasOwnProperty() function on an undefined object.

Sorry if this didn't add to your specific use case but I believe this to be a good design to adapt when managing objects and their properties.

Using ramda#dissoc you will get a new object without the attribute regex:

const newObject = R.dissoc('regex', myObject);
// newObject !== myObject

You can also use other functions to achieve the same effect - omit, pick, ...