Eliminar propiedades de objetos (JavaScript)

6776

Digamos que creo un objeto de la siguiente manera:

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

¿Cómo debo eliminar la propiedad regexpara terminar con una nueva de la myObjectsiguiente manera?

let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
};
1
  • eliminar myObject.regex; // o eliminar myObject ['regex']; // o, var prop = "regex"; eliminar myObject [prop]; 3 de agosto a las 16:58
9077

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];

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

Si desea un nuevo objeto con todas las claves del original excepto algunas, puede usar la desestructuración .

Manifestació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
3
  • 1
    Esta es una buena forma de hacerlo, pero solo es buena si realmente la va a usar regex, de lo contrario, eslint se quejará de una variable no utilizada. 11 de junio a las 14:45
  • @Loolooii puede cambiar el nombre de la variable en su asignación de desestructuración para cumplir argsIgnorePatterncon la no-unused-varsregla. Problema fácil de resolver. 27 de julio a las 16:29
  • El problema que he tenido con este enfoque es que si la destrucción está dentro de un condicional, ESlint se vuelve loco. 24 de agosto a las 21:56
1026

Los objetos en JavaScript se pueden considerar como 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 libera memoria directamente, y se diferencia de simplemente asignar el valor de nulloa undefineduna propiedad, en que la propiedad en se elimina 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 será recolectado como basura hasta que todas las referencias a él hayan desaparecido.

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

0
287

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.

0
268

Pregunta antigua, 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);

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


Editar:

Para reasignar a la misma variable, use un let:

let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);
2
  • ¿Cómo desestructuraré si el nombre de la propiedad varía, es decir, si lo tengo en una variable?
    Ceres
    14 de septiembre a las 18:02
  • Vea esta respuesta a continuación; stackoverflow.com/a/52301527
    Koen.
    15 de septiembre a las 19:48
258

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].

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

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

  • Un forbucle tradicional regresará undefinedpor el valor en el índice.

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

  • forEach, mapY reducese puede omitir el índice faltante.

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.

Matriz # empalme (inicio [, 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 desde el í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 ([begin [, end]])

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 de base cero en el que detenerse. Si endes 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#popelimina el último elemento de una matriz y devuelve ese elemento. Esta operación cambia la longitud de la matriz.

0
195

Sintaxis de propagación (ES6)

Para completar la respuesta de Koen , en caso de que desee eliminar una 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 algunas formas comunes de eliminar una propiedad de un objeto.
Cada uno tiene sus pros y sus contras ( consulte esta comparación de rendimiento ):

Eliminar operador

Es legible y breve, sin embargo, 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

Es más de dos veces más rápido que delete, sin embargo, la propiedad no se elimina y se puede iterar.

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

Operador de propagación

Este ES6operador 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 que se use cuando necesite eliminar muchas propiedades a la vez.

{ [key]: val, ...rest } = obj;
1
  • 1
    Esto no está eliminando la propiedad, está creando una copia superficial y no copiando la clave y el valor especificados. Esa es una gran diferencia.
    RobG
    30 oct.20 a las 5:40
110

Otra alternativa es usar la biblioteca Underscore.js .

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

Referencia: enlace _.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: enlace _.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.

0
84

Para clonar un objeto sin una propiedad:

Por ejemplo:

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

Y necesitamos eliminar a.

  1. Con una clave de apoyo explícita :

    const { a, ...rest } = object;
    object = rest;
    
  2. Con una tecla de apoyo variable :

    const propKey = 'a';
    const { [propKey]: propValue, ...rest } = object;
    object = rest;
    
  3. Una función de flecha genial 😎:

     const removeProperty = (propKey, { [propKey]: propValue, ...rest }) => rest;
    
     object = removeProperty('a', object);
    
  4. Para múltiples propiedades

    const removeProperties = (object, ...keys) => (keys.length ? removeProperties(removeProperty(keys.pop(), object), ...keys) : object);
    

Uso

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

O

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

El término que ha utilizado en el título de su pregunta, Eliminar una propiedad de un objeto JavaScript , 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, 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 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 elimina de su objeto myJSONObject, ese objeto específico no se eliminará de la memoria, ya que la regexvariable y myOtherObject["regex"]aún tendrá 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, apuntar a ese mismo objeto y tampoco usar vardeclaraciones para crear nuevas referencias a ese objeto . Este último punto con respecto a las vardeclaraciones, es uno de los temas más cruciales a los que nos enfrentamos habitualmente, 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"]como su última referencia existente, podría haber hecho esto simplemente eliminándola 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:

Setting a property to null before deleting it doesn't accomplish anything (unless the object has been sealed by Object.seal and the delete fails. That's not usually the case unless you specifically try).

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

48

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 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). deletePropertyLa función (así como el operador de eliminación ) regresa 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
0
45

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

Si bien técnicamente puede usarlo deletepara una matriz, usarlo daría como resultado la obtención de 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. El uso deletetambién estropearía su indexación.

Por lo tanto, cuando elimine 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.

36

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

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

Usar el método de eliminación 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'];

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().

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

27

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);
24

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.

0
23

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.

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

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

17

Pruebe el siguiente método. Asignar el Objectvalor de la propiedad a undefined. Luego stringifyel objeto y parse.

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

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

console.log(myObject);
0
12

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: {}}}
0
10

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

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" }
0
10

La afirmación de Dan de que "eliminar" es muy lenta y se puso en duda el índice 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.

10

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}
0
9

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 de 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 mapeadas 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 sus objetivos. 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 con 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 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 en el lugar no es apátrida, puede usar la naturaleza funcional de Reflect.deletePropertypara realizar aplicaciones parciales y otras técnicas funcionales que no son posibles con deletedeclaraciones.

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

@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 }
0
8

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)
3
  • pero el método filter () crea una matriz llena con todos los elementos de la matriz que pasan una prueba, por lo que el único propósito del filtro es reducir y crear una nueva matriz 16 de sep de 2020 a las 6:15
  • Sí, lo hace, pero eso solo es útil si está utilizando el valor devuelto del filtro al renunciar a la variable original u otra, y también solo funciona si se le da un valor de retorno en la función que se le pasa como parámetro, pero ninguno si esas cosas se hacen aquí, por lo que su único propósito es iterar los elementos de la matriz, que es para lo que sirve para cada uno 16 de septiembre de 2020 a las 6:20
  • 1
    En su lugar podrías hacer let filter = Object.fromEntries(Object.entries(myObject).filter(d => d !== 'regex' )) 16 de septiembre de 2020 a las 6:21
7

He usado Lodash "unset" para que suceda también para un objeto anidado ... solo esto necesita escribir una pequeña lógica para obtener la ruta de la clave de propiedad que espera el método de omisión .

  1. Método que devuelve la ruta de la propiedad como una 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. Luego, simplemente usando el método unset de Lodash , elimine la propiedad del objeto.

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

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 una a2dmatriz usando Object.entriesy usar empalme para eliminar un elemento como lo haría en una matriz normal, o simplemente filtrar a través del objeto, como lo haría con una matriz, y asignar el objeto reconstruido a la variable original

3

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);
1

Dos formas de eliminar un objeto

  1. usando para ... en

     function deleteUser(key) {
    
         const newUsers = {};
         for (const uid in users) {
             if (uid !== key) {
                 newUsers[uid] = users[uid];
             }
    
         return newUsers
     }
    

o

delete users[key]
2
  • Entonces, ¿está recomendando que para eliminar una propiedad, todo el objeto se copie en un nuevo objeto sin la propiedad de destino? 7 de junio a las 7:07
  • ¿Es ese código válido? Un }parece faltar. Puede editar su respuesta , pero sin "Editar:", "Actualizar:" o similar, la respuesta debería aparecer como si estuviera escrita hoy. 23 de junio a las 20:38