Digamos que creo un objeto de la siguiente manera:

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

¿Cuál es la mejor manera de eliminar la propiedad regexpara terminar con la nueva de la myObjectsiguiente manera?

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

Me gusta esto:

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

Manifestació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 profunda sobre la deletedeclaración en su blog, Entendiendo la eliminación . Es muy recomendable

Los objetos en JavaScript pueden considerarse mapas entre claves y valores. El deleteoperador se utiliza para eliminar estas claves, más comúnmente conocidas como propiedades de objeto, una a la vez.

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

El deleteoperador no directamente memoria libre, y se diferencia de la simple asignación del valor de nullo undefineda una propiedad, en el que la propiedad en sí es retirado del objeto. Tenga en cuenta que si el valor 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 se recolectará basura hasta que todas las referencias a él tengan desaparecido

delete solo funcionará en propiedades cuyo descriptor los 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.

El deleteoperador se utiliza para eliminar propiedades de los objetos.

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

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

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

Detalles

deleteen 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 deleteno se traslada array[3]a array[2].

Las diferentes funciones integradas en JavaScript manejan matrices dispersas de manera diferente.

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

• Un forbucle tradicional devolverá undefinedel valor en el índice.

• Cualquier método que use Symbol.iteratordevolverá undefinedel valor en el índice.

• forEach, mapy reducesimplemente omitirá el índice que falta.

Por lo tanto, el deleteoperador 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.

Array # splice (start [, deleteCount [, item1 [, item2 [, ...]]]])

Array#splicemuta la matriz y devuelve los índices eliminados. deleteCountlos elementos se eliminan del índice starty item1, item2... itemNse insertan en la matriz del índice start. Si deleteCountse 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 un nombre similar, pero diferente, la función de Array.prototype: Array#slice.

Array # slice ([comienzo [, fin]])

Array#sliceno es destructivo y devuelve una nueva matriz que contiene los índices indicados de starta end. Si no endse especifica, el valor predeterminado es el final de la matriz. Si endes positivo, especifica el índice no inclusivo basado en cero para detenerse. Si endes negativo, especifica el índice para 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]

Array # pop

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

Vieja pregunta, respuesta moderna. Usando la desestructuración de objetos, una característica de ECMAScript 6 , 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);

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

Editar:

Para reasignar a la misma variable, use a let:

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

Sintaxis extendida (ES6)

A quien lo necesite ...

Para completar la respuesta @Koen en este hilo, en caso de que desee eliminar la variable dinámica utilizando 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 }

* fooserá una nueva variable con el valor de a(que es 1).

RESPUESTA EXTENDIDA 😇
Hay pocas formas comunes de eliminar una propiedad de un objeto.
Cada uno tiene sus propios pros y contras ( consulte esta comparación de rendimiento ):

Eliminar Operador
Legible y breve, sin embargo, puede que no sea la mejor opción si está operando en 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 quedelete, sin embargo, la propiedadno seelimina y puede iterarse.

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

Operador de propagación
EsteES6operador nos permite devolver un objeto nuevo, excluyendo cualquier propiedad, sin mutar el objeto existente. La desventaja es que tiene el peor rendimiento de lo anterior y no se sugiere su uso cuando necesita eliminar muchas propiedades a la vez.

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

Otra alternativa es usar la biblioteca Underscore.js .

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 hacer el truco (no se muestra).

Referencia: enlace _.pick (objeto, * teclas)

Devuelve una copia del objeto, filtrada para que solo tenga valores para las claves incluidas en la lista blanca (o conjunto de claves válidas).

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

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

Referencia: link _.omit (objeto, * teclas)

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

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

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

Para matrices, _.filter()y _.reject()se pueden usar de manera similar.

El término que ha utilizado en el título de su pregunta Remove a property from a JavaScript objectpuede interpretarse de diferentes maneras. El primero es eliminarlo de la memoria completa y la lista de claves de objeto o el otro es simplemente eliminarlo de su objeto. Como se ha mencionado en algunas otras respuestas, la deletepalabra 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 su clave de objetos usando Object.keys(myJSONObject)sería:

["ircEvent", "method"]

Pero el punto es que si le importa la memoria y desea completar la eliminación del objeto de la memoria, se recomienda configurarlo como 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"];

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

La respuesta sería eliminar todas las referencias que tiene en su código, apuntado a ese mismo objeto y también no usar vardeclaraciones para crear nuevas referencias a ese objeto . Este último punto con respecto a las vardeclaraciones, es uno de los problemas más cruciales que generalmente enfrentamos, porque el uso de vardeclaraciones evitaría que el objeto creado se elimine.

Lo que significa que en este caso no podrá eliminar ese objeto porque ha creado la regexvariable a través de una vardeclaració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"]su última referencia existente, podría haberlo hecho simplemente eliminándola como:

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

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

Actualización: Gracias a @AgentME:

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

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

ECMAScript 2015 (o ES6) vino con un objeto Reflect incorporado . Es posible eliminar la propiedad del objeto llamando a la función Reflect.deleteProperty () 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 delete:

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). deletePropertyLa función (así como el operador de eliminación ) vuelve falsecuando intenta eliminar cualquiera de sus propiedades. Si la propiedad es configurable, regresa true, incluso si la propiedad no existe.

La diferencia entre deletey deletePropertyes 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

Supongamos que tiene un objeto que se ve así:

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 toda la staffmatriz, la forma correcta de hacerlo sería hacerlo:

delete Hogwarts.staff;

Alternativamente, también puedes hacer esto:

delete Hogwarts['staff'];

Del mismo modo, la eliminación de toda la matriz de estudiantes se haría llamando a delete Hogwarts.students;o 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 puede hacer esto:

Hogwarts.staff.splice(3, 1);

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

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

Nota

Si bien técnicamente puede usarlo deletepara una matriz, usarlo daría como resultado resultados incorrectos al llamar, por ejemplo, Hogwarts.staff.lengthmás adelante. En otras palabras, deleteeliminaría el elemento, pero no actualizaría el valor de la lengthpropiedad. Utilizandodelete también arruinaría tu indexación.

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

Si quieres experimentar con esto, puedes usar este Fiddle como punto de partida.

Usando ES6:

(Desestructuración + Operador de propagación)

const myObject = {
    regex: "^http://.*",
    b: 2,
    c: 3
};
const { regex, ...noRegex } = myObject;
console.log(noRegex); // => { b: 2, c: 3 }

Personalmente uso Underscore.js o Lodash para la manipulación de objetos y matrices:

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

El operador de eliminación es la mejor manera de hacerlo.

Un ejemplo en vivo para mostrar:

var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.

Para clonar objeto sin propiedad:

Por ejemplo:

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

Y necesitamos eliminar '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.Función de flecha fría 😎:

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

object = removePropery('a', object);

4. Para 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 }

O

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

El uso del método delete es la mejor manera de hacerlo, según la descripción de MDN, el operador delete elimina una propiedad de un objeto. Entonces simplemente puedes escribir:

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

El operador de eliminación elimina una propiedad determinada de un objeto. Al eliminar con éxito, 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 de prototipo del objeto, entonces, después de la eliminación, el objeto usará la propiedad de la cadena de prototipo (en otras palabras, eliminar solo tiene un 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 parte de una definición de función o una función (expresión).

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

• 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 da otro ejemplo simple:

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 siguiente enlace:

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 desea crear un nuevo objeto sin la clave 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);

Esta publicación es muy antigua y me resulta muy útil, así que decidí compartir la función sin configurar 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 sin configurar de PHP.

La razón para escribir esta nueva unsetfunció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 de 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"}

Hay muchas buenas respuestas aquí, pero solo quiero decir que cuando use eliminar 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 sabe si la propiedad existe o no. Comprobar si existe obj 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.

Usando 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, ...

Prueba el siguiente método. Asignar el Objectvalor de la propiedad a undefined. Entonces stringifyel 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: {}}}

Simplemente puede eliminar cualquier propiedad de un objeto usando la deletepalabra clave.

Por ejemplo:

var obj = {key1:"val1",key2:"val2",key3:"val3"}

Para eliminar cualquier propiedad, por ejemplo key1, use la deletepalabra clave como esta:

delete obj.key1

O también puede usar la notación tipo matriz:

delete obj[key1]

Ref: MDN .

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"];
        }
    }
);

La afirmación de Dan de que "eliminar" es muy lenta y se cuestionó el punto de referencia que publicó. Así que realicé la prueba yo mismo en Chrome 59. Parece que 'eliminar' es aproximadamente 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 a propósito realicé más de una operación de 'eliminación' en un ciclo de ciclo para minimizar el efecto causado por las otras operaciones.

Considere crear un nuevo objeto sin la "regex"propiedad porque otras partes de su programa siempre pueden hacer referencia al objeto original. Por lo tanto, debe evitar manipularlo.

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

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

console.log(newMyObject);

Eliminación de propiedades en JavaScript

Hay muchas opciones diferentes presentadas en esta página, no porque la mayoría de las opciones sean incorrectas o porque las respuestas sean duplicadas, sino porque la técnica adecuada depende de la situación en la que se encuentre y de los objetivos de las tareas que usted o usted El equipo está tratando de cumplir. Para responder su pregunta inequívocamente, uno necesita saber:

1. La versión de ECMAScript a la que se dirige
2. El rango de tipos de objetos de los que desea eliminar propiedades y el tipo de nombres de propiedad que debe poder omitir (¿Solo cadenas? ¿Símbolos? ¿Referencias débiles asignadas de objetos arbitrarios? Todos estos han sido tipos de punteros de propiedad en JavaScript desde hace años) )
3. El ethos / patrones de programación que usted y su equipo usan. ¿Favorece los enfoques funcionales y la mutación está verboten en su equipo, o emplea técnicas orientadas a objetos mutantes 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, hay esencialmente cuatro categorías de "eliminación de propiedades" en JavaScript para elegir para cumplir sus objetivos. Son:

Eliminación de propiedad de objeto mutante, insegura

Esta categoría es para operar en literales de objeto o instancias de objeto cuando desea conservar / continuar utilizando la referencia original y no está utilizando 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 más antigua, más directa y más ampliamente admitida de eliminación de propiedades. Admite Symbolíndices de matriz además de cadenas y funciona en todas las versiones de JavaScript, excepto en la primera versión. Sin embargo, es mutante, lo que viola algunos principios de programación y tiene implicaciones de rendimiento. También puede generar excepciones no detectadas cuando se usa en propiedades no configurables en modo estricto .

Omisión de propiedad de cadena basada en descanso

Esta categoría es para operar en objetos simples o instancias de matriz en nuevos sabores ECMAScript cuando se desea un enfoque no mutativo y no es necesario tener en cuenta las teclas de símbolos:

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 propiedad de objeto mutante, segura

Esta categoría es para operar en literales de objeto o instancias de objeto cuando desea retener / continuar usando la referencia original mientras protege contra las excepciones que se generan 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, aunque la mutación de objetos en el lugar no es apátrida, puede usar la naturaleza funcional de Reflect.deletePropertyhacer una aplicación parcial y otras técnicas funcionales que no son posibles con las deletedeclaraciones.

Omisión de propiedad de cadena basada en sintaxis

Esta categoría es para operar en objetos simples o instancias de matriz en nuevos sabores ECMAScript cuando se desea un enfoque no mutativo y no es necesario tener en cuenta las teclas de símbolos:

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 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"

Puede utilizar la desestructuración ES6 con el operador de reposo.

Las propiedades se pueden eliminar mediante la desestructuración en combinación con el operador de descanso . En su ejemplo, la expresión regular se desestructura (se ignora) y el resto de las propiedades se devuelven como descanso.

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

console.log(noRegex(myObjext)) //=> {  "ircEvent": "PRIVMSG","method": "newURI" }

O puede excluir dinámicamente propiedades como esta,

const myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};
const removeProperty = prop => ({ [prop]: _, ...rest }) => rest

const removeRegex = removeProperty('regex') //=> {  "ircEvent": "PRIVMSG","method":"newURI" }
const removeMethod = removeProperty('method') //=> {  "ircEvent": "PRIVMSG", "regex":"^http://.*" }

Podemos eliminar cualquier propiedad de un objeto javascript usando lo siguiente:

1. eliminar object.property
2. eliminar objeto ['propiedad']

ejemplo:

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

console.log(myObject);

delete myObject.regex;
console.log('=================');
console.log(myObject);
delete myObject['method'];
console.log('=================');
console.log(myObject);

Prueba esto

delete myObject['key'];