Para eliminar una propiedad de un objeto (mutando el objeto), puede hacerlo así:

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

De demostración

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

console.log(myObject);

Para cualquier persona interesada en leer más sobre esto, el usuario de Stack Overflow Kangax ha escrito una publicación de blog increíblemente detallada sobre la delete declaración en su blog, Entendiendo borrar. Es muy recomendable.

Si quieres un nueva objeto con todas las claves del original excepto algunas, puede utilizar el desestructuración.

De demostración

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

const {regex, ...newObj} = myObject;

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

Los objetos en JavaScript se pueden considerar como mapas entre claves y valores. La delete El operador se utiliza para eliminar estas claves, más comúnmente conocidas como propiedades de objeto, una por una.

var obj = {
  myProperty: 1    
}
console.log(obj.hasOwnProperty('myProperty')) // true
delete obj.myProperty
console.log(obj.hasOwnProperty('myProperty')) // false

LA delete El operador no libera memoria directamente, y se diferencia de simplemente asignar el valor de null or undefined a una propiedad, en que la propiedad sí mismo se elimina del objeto. Tenga en cuenta que si el propuesta de de una propiedad eliminada era un tipo de referencia (un objeto), y otra parte de su programa todavía tiene una referencia a ese objeto, entonces ese objeto, por supuesto, no será recolectado como basura hasta que todas las referencias hayan desaparecido.

delete solo funcionará en propiedades cuyo descriptor las marque como configurables.

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

console.log ( myObject.regex); // logs: undefined

Esto funciona en Firefox e Internet Explorer, y creo que funciona en todos los demás.

LA delete El operador se utiliza para eliminar propiedades de los objetos.

const obj = { foo: "bar" }
delete obj.foo
obj.hasOwnProperty("foo") // false

Tenga en cuenta que, para matrices, esto no es lo mismo que eliminar un elemento. Para eliminar un elemento de una matriz, use Array#splice or Array#pop. Por ejemplo:

arr // [0, 1, 2, 3, 4]
arr.splice(3,1); // 3
arr // [0, 1, 2, 4]

Detalles

delete en JavaScript tiene una función diferente a la de la palabra clave en C y C ++: no libera memoria directamente. En cambio, su único propósito es eliminar propiedades de los objetos.

Para las matrices, al eliminar una propiedad correspondiente a un índice, se crea una matriz dispersa (es decir, una matriz con un "agujero"). La mayoría de los navegadores representan estos índices de matriz faltantes como "vacíos".

var array = [0, 1, 2, 3]
delete array[2] // [0, 1, empty, 3]

Tenga en cuenta que delete no se reubica array[3] dentro array[2].

Diferentes funciones integradas en JavaScript manejan matrices dispersas de manera diferente.

• for...in omitirá el índice vacío por completo.

• Un tradicional for bucle volverá undefined para el valor en el índice.

• Cualquier método que utilice Symbol.iterator regresará undefined para el valor en el índice.

• forEach, map y reduce simplemente omitirá el índice que falta.

Por lo tanto, la delete El operador no debe usarse para el caso de uso común de eliminar elementos de una matriz. Las matrices tienen métodos dedicados para eliminar elementos y reasignar memoria: Array#splice() y Array#pop.

Matriz # empalme (inicio [, deleteCount [, item1 [, item2 [, ...]]]])

Array#splice muta la matriz y devuelve los índices eliminados. deleteCount los elementos se eliminan del índice start y item1, item2... itemN se insertan en la matriz desde el índice start. Si deleteCount se omite, los elementos de startIndex se eliminan al final de la matriz.

let a = [0,1,2,3,4]
a.splice(2,2) // returns the removed elements [2,3]
// ...and `a` is now [0,1,4]

También hay una función de nombre similar, pero diferente, en Array.prototype: Array#slice.

Array # slice ([begin [, end]])

Array#slice no es destructivo y devuelve una nueva matriz que contiene los índices indicados de start a end. Si end se deja sin especificar, el valor predeterminado es el final de la matriz. Si end es positivo, especifica la base cero no inclusivo índice en el que detenerse. Si end es negativo, especifica el índice en el que detenerse contando desde el final de la matriz (por ejemplo, -1 omitirá el índice final). Si end <= start, el resultado es una matriz vacía.

let a = [0,1,2,3,4]
let slices = [
    a.slice(0,2),
    a.slice(2,2),
    a.slice(2,3),
    a.slice(2,5) ]

//   a           [0,1,2,3,4]
//   slices[0]   [0 1]- - -   
//   slices[1]    - - - - -
//   slices[2]    - -[3]- -
//   slices[3]    - -[2 4 5]

Matriz # pop

Array#pop elimina el último elemento de una matriz y devuelve ese elemento. Esta operación cambia la longitud de la matriz.

Pregunta antigua, respuesta moderna. Usando la desestructuración de objetos, un ECMAScript 6 característica, es tan simple como:

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

O con la muestra de preguntas:

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

Puede verlo en acción en el editor de prueba de Babel.

Edit:

Para reasignar a la misma variable, use un let:

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

Sintaxis de propagación (ES6)

A quien lo necesite ...

Para completar la respuesta de @Koen en este hilo, en caso de que desee eliminar la variable dinámica usando la sintaxis de propagación, puede hacerlo así:

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 será una nueva variable con el valor de a (que es 1).

RESPUESTA AMPLIADA 😇
Hay algunas formas comunes de eliminar una propiedad de un objeto.
Cada uno tiene sus pros y sus contras (comprobar esta comparación de rendimiento):

Eliminar operador
Sin embargo, legible y breve, puede que no sea la mejor opción si está operando con una gran cantidad de objetos, ya que su rendimiento no está optimizado.

delete obj[key];

Reasignación
Más de 2 veces más rápido que delete, sin embargo la propiedad es no eliminado y se puede iterar.

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

Operador de propagación
Esta ES6 El operador nos permite devolver un objeto nuevo, excluyendo cualquier propiedad, sin mutar el objeto existente. La desventaja es que tiene el peor rendimiento de los anteriores y no se sugiere usarlo cuando necesita eliminar muchas propiedades a la vez.

{ [key]: val, ...rest } = obj;

Otra alternativa es utilizar el Underscore.js biblioteca.

Tenga en cuenta que _.pick() y _.omit() ambos devuelven una copia del objeto y no modifican directamente el objeto original. Asignar el resultado al objeto original debería funcionar (no se muestra).

Referencia: aquí _.pick (objeto, * claves)

Devuelve una copia del objeto, filtrado para tener solo valores para las claves en la lista blanca (o matriz de claves válidas).

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

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

Referencia: aquí _.omit (objeto, * claves)

Devuelve una copia del objeto, filtrada para omitir las claves de la lista negra (o matriz de claves).

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

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

Para matrices, _.filter() y _.reject() se puede utilizar de forma similar.

El término que ha utilizado en el título de su pregunta Remove a property from a JavaScript object, se puede interpretar de diferentes formas. Uno es eliminarlo para toda la memoria y la lista de claves de objeto o el otro es simplemente eliminarlo de su objeto. Como se ha mencionado en algunas otras respuestas, el delete la palabra clave es la parte principal. Digamos que tienes tu objeto como:

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

Si lo haces:

console.log(Object.keys(myJSONObject));

el resultado sería:

["ircEvent", "method", "regex"]

Puede eliminar esa clave específica de sus claves de objeto como:

delete myJSONObject["regex"];

Entonces tu clave de objetos usando Object.keys(myJSONObject) sería:

["ircEvent", "method"]

Pero el punto es que si le importa la memoria y desea que todo el objeto se elimine de la memoria, se recomienda establecerlo en nulo antes de eliminar la clave:

myJSONObject["regex"] = null;
delete myJSONObject["regex"];

El otro punto importante aquí es tener cuidado con sus otras referencias al mismo objeto. Por ejemplo, si crea una variable como:

var regex = myJSONObject["regex"];

O agréguelo como un nuevo puntero a otro objeto como:

var myOtherObject = {};
myOtherObject["regex"] = myJSONObject["regex"];

Entonces, incluso si lo quita de su objeto myJSONObject, ese objeto específico no se eliminará de la memoria, ya que el regex variable y myOtherObject["regex"] aún conservan sus valores. Entonces, ¿cómo podríamos eliminar el objeto de la memoria con seguridad?

La respuesta sera elimine todas las referencias que tenga en su código, apuntando a ese mismo objeto y también No utilice var declaraciones para crear nuevas referencias a ese objeto. Este último punto con respecto var declaraciones, es uno de los problemas más cruciales a los que generalmente nos enfrentamos, porque el uso de var Las declaraciones evitarían que el objeto creado se elimine.

Lo que significa que en este caso no podrá eliminar ese objeto porque ha creado el regex variable a través de un var declaración, y si lo hace:

delete regex; //False

El resultado sería false, lo que significa que su declaración de eliminación no se ha ejecutado como esperaba. Pero si no había creado esa variable antes, y solo tenía myOtherObject["regex"] como su última referencia existente, podría haber hecho esto simplemente eliminándolo como:

myOtherObject["regex"] = null;
delete myOtherObject["regex"];

En otras palabras, un objeto JavaScript se elimina tan pronto como no queda ninguna referencia en su código que apunte a ese objeto.

Actualizar: Gracias a @AgentME:

Establecer una propiedad en nula antes de eliminarla no logra nada (a menos que el objeto haya sido sellado por Object.seal y la eliminación falle. Ese no suele ser el caso a menos que lo intente específicamente).

Para obtener más información sobre Object.seal: Object.seal ()

Para clonar un objeto sin propiedad:

Por ejemplo:

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

Y necesitamos borrar a.

1. ¡Con clave de apoyo explícita:

    const { a, ...rest } = object;
    object = rest;

2. ¡Con clave de apoyo variable:

    const propKey = 'a';
    const { [propKey]: propValue, ...rest } = object;
    object = rest;

3. Frio función de flecha 😎:

    const removeProperty = (propKey, { [propKey]: propValue, ...rest }) => rest;

    object = removeProperty('a', object);

4. Si múltiples propiedades

    const removeProperties = (object, ...keys) => Object.entries(object).reduce((prev, [key, value]) => ({...prev, ...(!keys.includes(key) && { [key]: value }) }), {})

Uso

object = removeProperties(object, 'a', 'b') // result => { c: 3 }

Or

    const propsToRemove = ['a', 'b']
    object = removeProperties(object, ...propsToRemove) // result => { c: 3 }

ECMAScript 2015 (o ES6) vino con una función Reflejar objeto. Es posible eliminar la propiedad del objeto llamando Reflect.deleteProperty () función con el objeto de destino y la clave de propiedad como parámetros:

Reflect.deleteProperty(myJSONObject, 'regex');

que es equivalente a:

delete myJSONObject['regex'];

Pero si la propiedad del objeto no es configurable, no se puede eliminar ni con la función deleteProperty ni con el operador de eliminación:

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

Object.freeze () hace que todas las propiedades del objeto no sean configurables (además de otras cosas). deleteProperty función (así como eliminar operador) devoluciones false cuando intenta eliminar cualquiera de sus propiedades. Si la propiedad es configurable, regresa true, incluso si la propiedad no existe.

La diferencia entre los delete y deleteProperty es cuando se usa el modo estricto:

"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

Suponga que tiene un objeto que se parece a esto:

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

Eliminar una propiedad de objeto

Si desea utilizar todo staff array, la forma correcta de hacer esto, sería hacer esto:

delete Hogwarts.staff;

Alternativamente, también puede hacer esto:

delete Hogwarts['staff'];

De manera similar, eliminar toda la matriz de estudiantes se haría llamando delete Hogwarts.students; or delete Hogwarts['students'];.

Eliminar un índice de matriz

Ahora, si desea eliminar a un solo miembro del personal o estudiante, el procedimiento es un poco diferente, porque ambas propiedades son matrices en sí mismas.

Si conoce el índice de su miembro del personal, simplemente podría hacer esto:

Hogwarts.staff.splice(3, 1);

Si no conoce el índice, también tendrá que hacer una búsqueda en el índice:

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

Nota

Aunque técnicamente puedes usar delete para una matriz, su uso daría como resultado la obtención de resultados incorrectos al llamar, por ejemplo Hogwarts.staff.length mas tarde. En otras palabras, delete eliminaría el elemento, pero no actualizaría el valor de length propiedad. Utilizando delete también estropearía su indexación.

Por lo tanto, al eliminar valores de un objeto, siempre considere primero si está tratando con propiedades de objeto o si está tratando con valores de matriz, y elija la estrategia adecuada en función de eso.

Si quieres experimentar con esto, puedes usar este violín como punto de partida

Yo personalmente uso Underscore.js or Lodash para la manipulación de objetos y matrices:

myObject = _.omit(myObject, 'regex');

Usar borrar El método es la mejor manera de hacerlo, según la descripción de MDN, el operador de eliminación elimina una propiedad de un objeto. Entonces simplemente puede escribir:

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

El operador de eliminación elimina una propiedad determinada de un objeto. Si se elimina correctamente, devolverá verdadero, de lo contrario, se devolverá falso. Sin embargo, es importante considerar los siguientes escenarios:

• Si la propiedad que está intentando eliminar no existe, eliminar no tendrá ningún efecto y devolverá verdadero

• Si existe una propiedad con el mismo nombre en la cadena del prototipo del objeto, después de la eliminación, el objeto utilizará la propiedad de la cadena del prototipo (en otras palabras, eliminar solo tiene efecto en las propiedades propias).

• Cualquier propiedad declarada con var no se puede eliminar del alcance global o del alcance de una función.

• Como tal, eliminar no puede eliminar ninguna función en el ámbito global (ya sea que sea parte de una definición de función o una función (expresión).

• Funciones que forman parte de un objeto (aparte del
  alcance global) se puede eliminar con delete.

• Cualquier propiedad declarada con let o const no se puede eliminar del alcance dentro del cual se definieron. Las propiedades no configurables no se pueden eliminar. Esto incluye propiedades de objetos integrados como Math, Array, Object y propiedades que se crean como no configurables con métodos como Object.defineProperty ().

El siguiente fragmento ofrece otro ejemplo sencillo:

var Employee = {
      age: 28,
      name: 'Alireza',
      designation: 'developer'
    }
    
    console.log(delete Employee.name);   // 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

Para obtener más información y ver más ejemplos, visite el enlace a continuación:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete

Otra solución, usando 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;
}, {});

console.log(myObject);

Sin embargo, mutar el objeto original. Si quieres crear un nuevo objeto sin la tecla especificada, simplemente asigne la función de reducción a una nueva variable, por ejemplo:

(ES6)

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;
}, {});

console.log(myNewObject);

Hay muchas buenas respuestas aquí, pero solo quiero decir que cuando se usa delete para eliminar una propiedad en JavaScript, a menudo es aconsejable verificar primero si esa propiedad existe para evitar errores.

P.ej

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

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

Debido a la naturaleza dinámica de JavaScript, a menudo hay casos en los que simplemente no se sabe si la propiedad existe o no. Verificar si obj existe antes de && también asegura que no arroje un error debido a llamar a la función hasOwnProperty () en un objeto indefinido.

Lo siento si esto no se agregó a su caso de uso específico, pero creo que este es un buen diseño para adaptarse al administrar objetos y sus propiedades.

Esta publicación es muy antigua y me parece muy útil, así que decidí compartir la función de desarmado que escribí en caso de que alguien más vea esta publicación y piense por qué no es tan simple como en la función de desarmado de PHP.

El motivo de escribir este nuevo unset función, es mantener el índice de todas las demás variables en este hash_map. Mire el siguiente ejemplo y vea cómo el índice de "test2" no cambió después de eliminar un valor del hash_map.

function unset(unsetKey, unsetArr, resort) {
  var tempArr = unsetArr;
  var unsetArr = {};
  delete tempArr[unsetKey];
  if (resort) {
    j = -1;
  }
  for (i in tempArr) {
    if (typeof(tempArr[i]) !== 'undefined') {
      if (resort) {
        j++;
      } else {
        j = i;
      }
      unsetArr[j] = tempArr[i];
    }
  }
  return unsetArr;
}

var unsetArr = ['test', 'deletedString', 'test2'];

console.log(unset('1', unsetArr, true)); // output Object {0: "test", 1: "test2"}
console.log(unset('1', unsetArr, false)); // output Object {0: "test", 2: "test2"}

Usar ramda # dissoc obtendrás un nuevo objeto sin el atributo regex:

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

También puede usar otras funciones para lograr el mismo efecto: omitir, seleccionar, ...

Pruebe el siguiente método. Asignar el Object valor de la propiedad a undefined. entonces stringify el objeto y parse.

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

myObject.regex = undefined;
myObject = JSON.parse(JSON.stringify(myObject));

console.log(myObject);

Si desea eliminar una propiedad profundamente anidada en el objeto, puede usar la siguiente función recursiva con la ruta a la propiedad como segundo argumento:

var deepObjectRemove = function(obj, path_to_key){
    if(path_to_key.length === 1){
        delete obj[path_to_key[0]];
        return true;
    }else{
        if(obj[path_to_key[0]])
            return deepObjectRemove(obj[path_to_key[0]], path_to_key.slice(1));
        else
            return false;
    }
};

Ejemplo:

var a = {
    level1:{
        level2:{
            level3: {
                level4: "yolo"
            }
        }
    }
};

deepObjectRemove(a, ["level1", "level2", "level3"]);
console.log(a);

//Prints {level1: {level2: {}}}

La afirmación de Dan de que "eliminar" es muy lenta y se puso en duda el punto de referencia que publicó. Así que realicé la prueba yo mismo en Chrome 59. Parece que "eliminar" es unas 30 veces más lento:

var iterationsTotal = 10000000;  // 10 million
var o;
var t1 = Date.now(),t2;
for (let i=0; i<iterationsTotal; i++) {
   o = {a:1,b:2,c:3,d:4,e:5};
   delete o.a; delete o.b; delete o.c; delete o.d; delete o.e;
}
console.log ((t2=Date.now())-t1);  // 6135
for (let i=0; i<iterationsTotal; i++) {
   o = {a:1,b:2,c:3,d:4,e:5};
   o.a = o.b = o.c = o.d = o.e = undefined;
}
console.log (Date.now()-t2);  // 205

Tenga en cuenta que intencionalmente llevé a cabo más de una operación de 'eliminación' en un ciclo de bucle para minimizar el efecto causado por las otras operaciones.

Eliminación de propiedades en JavaScript

En esta página se presentan muchas opciones diferentes, no porque la mayoría de las opciones sean incorrectas, o porque las respuestas estén duplicadas, sino porque la técnica adecuada depende de la situación en la que se encuentre y los objetivos de las tareas que usted y / o usted equipo está tratando de cumplir. Para responder a su pregunta de manera inequívoca, es necesario saber:

1. La versión de ECMAScript a la que se dirige
2. El rango de tipos de objetos en los que desea eliminar propiedades y el tipo de nombres de propiedad que debe poder omitir (¿solo cadenas? ¿Símbolos? ¿Referencias débiles asignadas a partir de objetos arbitrarios? Todos estos han sido tipos de punteros de propiedad en JavaScript durante años. )
3. Los patrones / valores de programación que usted y su equipo usan. ¿Prefieres los enfoques funcionales y la mutación está prohibida en tu equipo, o empleas técnicas mutativas orientadas a objetos del salvaje oeste?
4. ¿Está buscando lograr esto en JavaScript puro o está dispuesto y puede usar una biblioteca de terceros?

Una vez que se hayan respondido esas cuatro consultas, existen esencialmente cuatro categorías de "eliminación de propiedad" en JavaScript para elegir a fin de cumplir con sus objetivos. Ellos son:

Eliminación de propiedad de objeto mutativo, inseguro

Esta categoría es para operar en objetos literales o instancias de objetos cuando desea retener / continuar usando la referencia original y no está usando principios funcionales sin estado en su código. Un ejemplo de sintaxis en esta categoría:

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
delete iLikeMutatingStuffDontI[Symbol.for('amICool')] // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
delete iLikeMutatingStuffDontI['amICool'] // throws

Esta categoría es la categoría de eliminación de propiedad más antigua, más sencilla y con más soporte. Es compatible Symbol & array indexa además de las cadenas y funciona en todas las versiones de JavaScript excepto en la primera versión. Sin embargo, es mutativo que viola algunos principios de programación y tiene implicaciones de rendimiento. También puede dar lugar a excepciones no detectadas cuando se utiliza en propiedades no configurables en modo estricto.

Omisión de la propiedad de la cadena basada en el descanso

Esta categoría es para operar en instancias de objetos o matrices simples en sabores ECMAScript más nuevos cuando se desea un enfoque no mutativo y no es necesario tener en cuenta las claves de símbolo:

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

Eliminación de propiedades de objetos mutantes, segura

Esta categoría es para operar en objetos literales o instancias de objetos cuando desea retener / continuar usando la referencia original mientras se protege contra excepciones que se lanzan en propiedades no configurables:

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
Reflect.deleteProperty(iLikeMutatingStuffDontI, Symbol.for('amICool')) // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
Reflect.deleteProperty(iLikeMutatingStuffDontI, 'amICool') // false

Además, si bien la mutación de objetos in situ no es apátrida, puede utilizar la naturaleza funcional de Reflect.deleteProperty para hacer una aplicación parcial y otras técnicas funcionales que no son posibles con delete Declaraciones.

Omisión de propiedad de cadena basada en sintaxis

Esta categoría es para operar en instancias de objetos o matrices simples en sabores ECMAScript más nuevos cuando se desea un enfoque no mutativo y no es necesario tener en cuenta las claves de símbolo:

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

Omisión de propiedad basada en la biblioteca

Esta categoría generalmente permite una mayor flexibilidad funcional, incluida la contabilidad de los símbolos y la omisión de más de una propiedad en una declaración:

const o = require("lodash.omit")
const foo = { [Symbol.for('a')]: 'abc', b: 'b', c: 'c' }
const bar = o(foo, 'a') // "'a' undefined"
const baz = o(foo, [ Symbol.for('a'), 'b' ]) // Symbol supported, more than one prop at a time, "Symbol.for('a') undefined"

Usando lodash

import omit from 'lodash/omit';

const prevObject = {test: false, test2: true};
// Removes test2 key from previous object
const nextObject = omit(prevObject, 'test2');

Usando Ramda

R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}

Object.assign () y Object.keys () y Array.map ()

const obj = {
    "Filters":[
        {
            "FilterType":"between",
            "Field":"BasicInformationRow.A0",
            "MaxValue":"2017-10-01",
            "MinValue":"2017-09-01",
            "Value":"Filters value"
        }
    ]
};

let new_obj1 = Object.assign({}, obj.Filters[0]);
let new_obj2 = Object.assign({}, obj.Filters[0]);

/*

// old version

let shaped_obj1 = Object.keys(new_obj1).map(
    (key, index) => {
        switch (key) {
            case "MaxValue":
                delete new_obj1["MaxValue"];
                break;
            case "MinValue":
                delete new_obj1["MinValue"];
                break;
        }
        return new_obj1;
    }
)[0];


let shaped_obj2 = Object.keys(new_obj2).map(
    (key, index) => {
        if(key === "Value"){
            delete new_obj2["Value"];
        }
        return new_obj2;
    }
)[0];


*/


// new version!

let shaped_obj1 = Object.keys(new_obj1).forEach(
    (key, index) => {
        switch (key) {
            case "MaxValue":
                delete new_obj1["MaxValue"];
                break;
            case "MinValue":
                delete new_obj1["MinValue"];
                break;
            default:
                break;
        }
    }
);

let shaped_obj2 = Object.keys(new_obj2).forEach(
    (key, index) => {
        if(key === "Value"){
            delete new_obj2["Value"];
        }
    }
);

@johnstock, también podemos usar el concepto de creación de prototipos de JavaScript para agregar un método a los objetos para eliminar cualquier clave pasada disponible en el objeto de llamada.

Se agradecen las respuestas anteriores.

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

// 1st and direct way 
delete myObject.regex; // delete myObject["regex"]
console.log(myObject); // { ircEvent: 'PRIVMSG', method: 'newURI' }

// 2 way -  by using the concept of JavaScript's prototyping concept
Object.prototype.removeFromObjectByKey = function(key) {
  // If key exists, remove it and return true
  if (this[key] !== undefined) {
    delete this[key]
    return true;
  }
  // Else return false
  return false;
}

var isRemoved = myObject.removeFromObjectByKey('method')
console.log(myObject) // { ircEvent: 'PRIVMSG' }

// More examples
var obj = {
  a: 45,
  b: 56,
  c: 67
}
console.log(obj) // { a: 45, b: 56, c: 67 }

// Remove key 'a' from obj
isRemoved = obj.removeFromObjectByKey('a')
console.log(isRemoved); //true
console.log(obj); // { b: 56, c: 67 }

// Remove key 'd' from obj which doesn't exist
var isRemoved = obj.removeFromObjectByKey('d')
console.log(isRemoved); // false
console.log(obj); // { b: 56, c: 67 }

Puedes usar un filtro como el siguiente

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

// way 1

let filter1 = {}
  Object.keys({...myObject}).filter(d => {
  if(d !== 'regex'){
    filter1[d] = myObject[d];
  }
})

console.log(filter1)

// way 2

let filter2 = Object.fromEntries(Object.entries({...myObject}).filter(d => 
d[0] !== 'regex'
))

console.log(filter2)

He utilizado lodash "desarmado" para que suceda también para el objeto anidado ... solo es necesario escribir una pequeña lógica para obtener la ruta de la clave de propiedad que se esperaba mediante el método de omisión.

1. Método que devuelve la ruta de propiedad como matriz

var a = {"bool":{"must":[{"range":{"price_index.final_price":{"gt":"450","lt":"500"}}},{"bool":{"should":[{"term":{"color_value.keyword":"Black"}}]}}]}};

function getPathOfKey(object,key,currentPath, t){
     var currentPath = currentPath || [];

    for(var i in object){
		if(i == key){
        t = currentPath;
      }
      else if(typeof object[i] == "object"){
        currentPath.push(i)
       return getPathOfKey(object[i], key,currentPath)
      }
    }
	t.push(key);
    return t;
}
document.getElementById("output").innerHTML =JSON.stringify(getPathOfKey(a,"price_index.final_price"))

<div id="output"> 

</div>

1. Entonces solo usando lodash desarmado método elimina la propiedad del objeto.

var unset = require('lodash.unset');
unset(a,getPathOfKey(a,"price_index.final_price"));

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


obj = Object.fromEntries(
    Object.entries(myObject).filter(function (m){
        return m[0] != "regex"/*or whatever key to delete*/
    }
))

console.log(obj)

También puede tratar el objeto como a2d matriz usando Object.entries, y use empalme para eliminar un elemento como lo haría en una matriz normal, o simplemente filtre a través del objeto, como lo haría con una matriz, y asigne el objeto reconstruido de nuevo a la variable original

Aquí hay una forma ES6 de eliminar la entrada fácilmente:

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

const removeItem = 'regex';

const { [removeItem]: remove, ...rest } = myObject;

console.log(remove); // "^http://.*"
console.log(rest); // Object { ircEvent: "PRIVMSG", method: "newURI" }

Si no desea modificar el objeto original.

Eliminar una propiedad sin mutar el objeto

Si le preocupa la mutabilidad, puede crear un objeto completamente nuevo copiando todas las propiedades del antiguo, excepto la que desea eliminar.

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

let prop = 'regex';
const updatedObject = Object.keys(myObject).reduce((object, key) => {
  if (key !== prop) {
    object[key] = myObject[key]
  }
  return object
}, {})

console.log(updatedObject);

La forma obvia de eliminar una propiedad de un objeto es utilizar la palabra clave delete. esto se puede hacer así:

delete myObject['regex']

o esto:

delete myObject.regex

Si le preocupa la mutabilidad, puede crear un nuevo objeto copiando todas las propiedades del antiguo, excepto la que le gustaría eliminar.

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

const propertyToRemove = 'regex'
const newObject = Object.keys(myObject).reduce((object, key) => {
   if (key !== propertyToRemove ) {
      object[key] = car[key]
   }
return object }, {})