If you are using Underscore.js or Lodash, there is a function 'omit' that will do it. http://underscorejs.org/#omit var thisIsObject= {
'Cow' : 'Moo',
'Cat' : 'Meow',
'Dog' : 'Bark'
};
_.omit(thisIsObject,'Cow'); //It will return a new object
=> {'Cat' : 'Meow', 'Dog' : 'Bark'} //result
If you want to modify the current object, assign the returning object to the current object. thisIsObject = _.omit(thisIsObject,'Cow');
With pure JavaScript, use: delete thisIsObject['Cow'];
Another option with pure JavaScript. thisIsObject = Object.keys(thisIsObject).filter(key =>
key !== 'cow').reduce((obj, key) =>
{
obj[key] = thisIsObject[key];
return obj;
}, {}
);
The delete operator removes a property from an object. If the property's value is an object and there are no more references to the object, the object held by that property is eventually released automatically. Syntaxdelete object.property
delete object[property]
Note: The syntax allows a wider range of expressions following the delete operator, but only the above forms lead to meaningful behaviors. Parametersobject
The name of an object, or an expression evaluating to an object. property The property to delete. Return valuetrue for all cases except when the property is an own
non-configurable property, in which case false is returned in non-strict mode.
ExceptionsTypeError
Thrown in strict mode if the property is an own non-configurable property. ReferenceError Thrown if object is super . DescriptionThe delete operator has the same precedence as other unary operators like
typeof . Therefore, it accepts any expression formed by higher-precedence operators. However, the following forms lead to early syntax errors in strict mode: delete identifier;
delete object.#privateProperty;
Because
classes are automatically in strict mode, and private properties can only be legally referenced in class bodies, this means private properties can never be deleted. While delete identifier
may work if identifier refers to a configurable property of the global object, you should avoid this form and prefix it with globalThis instead. While other expressions are accepted, they don't lead to meaningful behaviors: delete console.log(1);
// Logs 1, returns true, but nothing deleted
The delete operator removes a given property from an object. On successful deletion, it will return true , else false will be returned. Unlike what common belief suggests (perhaps due to other programming languages like delete in C++), the delete operator has nothing to do with directly freeing memory. Memory management is done indirectly via
breaking references. See the memory management page for more details. 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 . delete only has an effect on own properties. 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.- 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() . - Deleting variables, including function parameters, never works.
delete variable will throw a
SyntaxError in strict mode, and will have no effect in non-strict mode. - Any variable declared with
var cannot be deleted from the global scope or from a function's scope, because while they may be attached to the
global object, they are not configurable. - Any variable declared with
let or const cannot be deleted from the scope within which they were defined, because they are
not attached to an object.
Cross-browser notesAs of modern ECMAScript specification, the traversal order of object properties is well-defined and stable across implementations. However, in the case of
Internet Explorer, when one uses delete on a property, some confusing behavior results, preventing other browsers from using simple objects like object literals as ordered associative arrays. In Explorer, while the property value is indeed set to undefined , if one later adds back a property with the same name, the property will be iterated in its old position — not at the end of the iteration sequence as one might expect after having deleted the property and then added it
back. If you want to use an ordered associative array with support of old runtimes, use a Map object if available (through a polyfill, for example), or simulate this structure with two separate arrays (one for the keys and the other for the values), or build an array of single-property objects, etc. Using deleteNote: The following example uses non-strict-mode only features,
like implicitly creating global variables and deleting identifiers, which are forbidden in strict mode. // Creates the property empCount on the global scope.
// Since we are using var, this is marked as non-configurable.
var empCount = 43;
// Creates the property adminName on the global scope.
// Since it was defined without "var", it is marked configurable.
EmployeeDetails = {
name: "xyz",
age: 5,
designation: "Developer",
};
// delete can be used to remove properties from objects.
delete EmployeeDetails.name; // returns true
// Even when the property does not exist, delete returns "true".
delete EmployeeDetails.salary; // returns true
// EmployeeDetails is a property of the global scope.
delete EmployeeDetails; // returns true
// On the contrary, empCount is not configurable
// since var was used.
delete empCount; // returns false
// delete also does not affect built-in static properties
// that are non-configurable.
delete Math.PI; // returns false
function f() {
var z = 44;
// delete doesn't affect local variable names
delete z; // returns false
}
delete and the prototype chainIn the following
example, we delete an own property of an object while a property with the same name is available on the prototype chain: function Foo() {
this.bar = 10;
}
Foo.prototype.bar = 42;
const foo = new Foo();
// foo.bar is associated with the
// own property.
console.log(foo.bar); // 10
// Delete the own property within the
// foo object.
delete foo.bar; // returns true
// foo.bar is still available in the
// prototype chain.
console.log(foo.bar); // 42
// Delete the property on the prototype.
delete Foo.prototype.bar; // returns true
// The "bar" property can no longer be
// inherited from Foo since it has been
// deleted.
console.log(foo.bar); // undefined
Deleting array elementsWhen you delete an array element, the
array length is not affected. This holds even if you delete the last element of the array. When the delete operator removes an array element, that element is no longer in the array. In the following example, trees[3] is removed with delete . const trees = ["redwood", "bay", "cedar", "oak", "maple"];
delete trees[3];
console.log(3 in trees); // false
This creates a sparse array with an empty slot. If you want an array element to exist but have an
undefined value, use the undefined value instead of the delete operator. In the following example, trees[3] is assigned the value undefined , but the array element still exists: const trees = ["redwood", "bay", "cedar", "oak", "maple"];
trees[3] = undefined;
console.log(3 in trees); // true
If instead, you want to remove an array element by changing the contents of the array, use the splice() method. In the following example, trees[3] is removed from the array
completely using splice() : const trees = ["redwood", "bay", "cedar", "oak", "maple"];
trees.splice(3, 1);
console.log(trees); // ["redwood", "bay", "cedar", "maple"]
Deleting non-configurable propertiesWhen a property is marked as non-configurable, delete won't have any effect, and will return false . In strict mode, this will raise a TypeError . const Employee = {};
Object.defineProperty(Employee, "name", { configurable: false });
console.log(delete Employee.name); // returns false
var creates non-configurable properties that cannot be deleted with the delete operator:
// Since "nameOther" is added using with the
// var keyword, it is marked as non-configurable
var nameOther = "XYZ";
// We can access this global property using:
Object.getOwnPropertyDescriptor(globalThis, "nameOther");
// Object {
// value: "XYZ",
// writable: true,
// enumerable: true,
// configurable: false
// }
delete globalThis.nameOther; // return false
In strict mode, this would raise an exception. Deleting global propertiesIf a global property is configurable (for example, via direct property assignment), it can be deleted, and subsequent references to them as global variables will produce a
ReferenceError . globalThis.globalVar = 1;
console.log(globalVar); // 1
// In non-strict mode, you can use `delete globalVar` as well
delete globalThis.globalVar;
console.log(globalVar); // ReferenceError: globalVar is not defined
Specifications
Specification |
---|
ECMAScript Language Specification # sec-delete-operator
|
Browser compatibilityBCD tables only load in the browser
How do I remove a key from a JavaScript object?
Use delete to Remove Object Keys
The special JavaScript keyword delete is used to remove object keys (also called object properties). While you might think setting an object key equal to undefined would delete it, since undefined is the value that object keys that have not yet been set have, the key would still exist.
How do I remove the value of an object in a key?
Using delete operator. When only a single key is to be removed we can directly use the delete operator specifying the key in an object. Syntax: delete(object_name.
How do I remove a specific key from an array of objects?
To remove a property from all objects in an array:
Use the Array. forEach() method to iterate over the array. On each iteration, use the delete operator to delete the specific property. The property will get removed from all objects in the array.
How do you remove a key from a node js object?
Use Destructuring to Delete a Property From an Object
You can remove a property from an object using destructuring in combination with the ... rest operator.
|