¿Cómo elimino una propiedad de un objeto JavaScript?


6142

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


@EscapeNetscape Esta es una pregunta sobre el comportamiento, por lo que un punto de referencia pinta la imagen equivocada. Por supuesto delete, sería la opción más lenta ya que es una operación real en lugar de las otras dos, que son solo tareas simples. Pero el quid de la cuestión es que la asignación de la propiedad de null, o undefineden realidad no quitar la propiedad del objeto, sino que establece que la propiedad a igual a un valor constante en particular. (Las respuestas a continuación dan razones por las cuales esta es una diferencia significativa.)
Abion47

Respuestas:


8308

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


47
Marcado, también funciona con "eliminar myJSONObject ['regex']; Ver: developer.mozilla.org/en/Core_JavaScript_1.5_Reference/…
johnstok

110
Un resultado de una de las observaciones en el enlace de "comprensión de eliminación" anterior es que, dado que no necesariamente puede eliminar una variable, sino solo las propiedades del objeto, por lo tanto, no puede eliminar una propiedad del objeto "por referencia" - var value = obj [ 'apuntalar']; eliminar valor // no funciona
Dexygen

27
Entonces, ¿en realidad no lo elimina? Simplemente se vuelve indefinido, pero la clave todavía existe? ¿Me estoy perdiendo de algo?
Doug Molineux

152
@Pete no, lo elimina. Dado: var x = {a : 'A', b : 'B'};Comparar: delete x.a; typeof x.a; /* "undefined" */ x.hasOwnProperty('a'); /* false */ax.b = undefined; typeof x.b; /* "undefined" */; x.hasOwnProperty('b'); /* true */
nickf

16
@ChristopherPfohl funciona para mí. Como dije, en realidad es bastante profundo, por lo que es un poco difícil de resumir. La respuesta básica en la respuesta anterior es suficiente para casi todos los casos, el blog aborda algunos de los casos más extremos y las razones por las que existen esos casos.
nickf

953

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.


43
una propiedad asignada a undefined aún es una propiedad de un objeto, por lo que GC no la eliminará, a menos que haya leído mal su último párrafo.
Lance

8
Me equivoqué al tocar el tema de GC aquí. Ambos métodos tienen el mismo resultado para GC: eliminan el valor vinculado a la clave. Si ese valor fuera la última referencia a algún otro objeto, ese objeto se limpiaría.
Dan

15
una propiedad asignada a undefined aún es una propiedad de un objeto, por lo que GC no la eliminará. GC no administra nada sobre las propiedades. Recopila y elimina valores. Mientras ya nada haga referencia a un valor (un objeto, una cadena, etc.), el GC lo elimina de la memoria.
meandre

8
Por cierto, ese es el doble problema para verificar si existe una propiedad en un objeto Javascript. El uso en operador es confiable pero lento. Compruebe si la propiedad no está definida "no es la respuesta correcta" pero es mucho más rápida. check
rdllopes

8
¿Sigue siendo relevante esta respuesta? jsperf está actualmente abajo, pero este punto de referencia parece indicar que la diferencia de velocidad es solo un 25%, que no está cerca del "~ 100 veces más lento" en esta respuesta.
Cerbrus

248

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.


216

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.


12
Este enfoque no modifica el objeto original al que todavía se puede hacer referencia en otro lugar. Esto podría o no ser un problema dependiendo de cómo se use, pero es algo a tener en cuenta.
Tamas Czinege

19
@ B1KMusic Aquí está la forma de eliminar un elemento de una matriz: empalme
wulftone

3
@wulftone nope, que divide la matriz y no hace nada para eliminar un valor. Realmente creo que la mejor manera de eliminar de una matriz donde se necesitan valores específicos para eliminar es usar deletey hacer una función de Recolección de Basura para limpiarlo.
Braden Best

55
No veo spliceen su edición, pero removedebería serArray.prototype.remove = function(index) { this.splice(index, 1); };
RY-

1
Este artículo está lleno de toro 1. ¡No aborda la pregunta! 2. Es un mal uso del lenguaje y una queja de que "no funciona". 3. No culpe al operador de eliminación de JavaScript por el error idiosincrásico de Crockford de poner nulo para un índice de matriz vacío. No entiende el significado de nulo, piensa que es un error. El error es suyo y solo: no hay un valor nulo en el valor eliminado de un índice de matriz dado. No hay un "agujero" en la matriz, es un índice vacío. Absolutamente legítimo y esperado.
Bekim Bacaj

195

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

66
Tal vez porque el objetivo es eliminar una propiedad de un objeto, no crear una nueva sin la propiedad ... aunque, su solución es mi favorita, ya que prefiero la forma inmutable.
Vingt_centimes

8
La pregunta decía "terminar con un nuevo myObject".
Koen

1
Adición de subrayado para la eliminación de una camada voluntad propiedad su proyecto :) En lugar de tener a disposición como regextambién se puede asignar a cualquier otra variable, por ejemplo _, lo que se utiliza en lenguajes como Go para descartar un resultado: const { regex: _, ...newObject } = myObject;.
Koen

2
@PranayKumar Esperaba que esta sintaxis funcionara; const { [key], ...newObject } = myObject;pero no es así, así que no creo que sea posible con la desestructuración.
Koen

2
Con freeze()los seal()objetos 'd' y 'd, no puede simplemente deleteuna propiedad. Entonces esta es una excelente alternativa. Aunque en la mayoría de los casos, probablemente no tenga sentido eliminar una propiedad de un objeto congelado / sellado de todos modos, teniendo en cuenta que el objetivo es hacer ciertas garantías sobre sus estructuras de datos, de las cuales este patrón estaría socavando. Para aquellos casos en los que necesita duplicar un objeto de forma no destructiva pero sin algunas de sus propiedades, esto es perfecto
Braden Best,

119

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;

2
Creo que la sintaxis spread / rest para literales de objeto solo se incluyó en ES2018 (ES9), no en ES6, a pesar de que varios motores JS ya lo habían implementado.
Trincot

2
@trincot Se introdujo por primera vez en 2014 ( github.com/tc39/proposal-object-rest-spread ) y es una función ES6 (ECMAScript 2015, también conocida como ECMAScript 6th Edition). Sin embargo, incluso si me equivoco, no creo que haya una diferencia en el contexto de la respuesta.
Lior Elrom

2
El enlace se refiere a ES6, donde de hecho se introdujo la sintaxis extendida para las matrices, pero luego continúa proponiendo algo similar para los literales de objeto. Esa segunda parte solo se incorporó en ES9 si no me equivoco.
trincot

98

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.


44
Tenga en cuenta que si las claves de su objeto son números, es posible que necesite_.omit(collection, key.toString())
Jordan Arseno

Hmmmmm ... El subrayado es ~ 100 veces más lento que el delete obj[prop]que es ~ 100 veces más lento que obj[prop] = undefined.
Jack Giffin

52

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


Estás equivocado: solo los objetos se pasan por referencia en JavaScript, por lo que si myJSONObject.regexel valor es una cadena y lo asignas a otro objeto, el otro objeto tiene una copia de este valor.
Michał Perłakowski

Tiene razón y esta es una cita: "tener cuidado con sus otras referencias al mismo objeto".
Mehran Hatami

43

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

1
@Gothdo tiene más beneficios, especialmente cuando necesitas hacer algunas cosas funcionales. Por ejemplo, puede asignar la función a la variable, pasa como argumento o el uso apply, call, bindfunciones ...
madox2

41

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.


Creo que siempre debe usar spliceen una matriz en lugar de delete.
Joel Trauger

@JoelTrauger: Eso es lo que estoy diciendo ;-)
John Slegers el

Si. Mi comentario es que eso deleteni siquiera debería ser una cosa. Es splicelo que estaba buscando el OP.
Joel Trauger el

1
@JoelTrauger: como traté de explicar, deletedebería usarse para las propiedades del objeto y splicepara los elementos de la matriz.
John Slegers

El empalme es realmente lento. Si bien debe usarse en lugar de deleteen matrices, sería mejor no crear código centrado en absoluto.
Jack Giffin

39

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 }

No creo que esta sea una función de ES6, pero que solo se incluyó en ES9.
Trincot

Así que en realidad no estás usando ES6, mientras escribes, sino ES9 ... ;-)
trincot

2
Esto no es eliminar una propiedad de un objeto, sino crear un nuevo objeto sin esa propiedad.
Jordi Nebot



29

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 }

1
Función de flecha pulida!
JSilv

27

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


22

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


21

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

20

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.


2
eliminar foo.bar funciona incluso si la barra no existe, por lo que su prueba es demasiado, en mi humilde opinión.
PhiLho

@PhiLho que depende de dónde esté ejecutando JavaScript. En Node.js, creo que esto hace que su servidor se bloquee.
Willem

2
delete foo.bar;solo genera una excepción si foo es falso o si está en modo estricto y foo es un objeto con una propiedad de barra no configurable.
Macil

No recuerdo el problema exacto que tuve con esto, pero creo que el problema puede aparecer cuando foo no existe e intenta eliminar su propiedad.
Willem

Sí, debe probar si existe foo, de lo contrario foo.bar arrojará una excepción, pero no necesita verificar la existencia de barra antes de eliminarla. Esa es la parte "demasiado" de mi comentario. :-)
PhiLho

16

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


15

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


1
TambiénJSON.parse(JSON.stringify({ ...myObject, regex: undefined }))
noisypixy

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

Esta función funciona a las mil maravillas, pero ¿por qué necesitamos devolver verdadero y devolver falso? Mi versión del código: codepen.io/anon/pen/rwbppY . ¿Mi versión fallará en algún caso?
habitual

@ witty2017 no fallará. El lugar donde utilicé la función también necesitaba verificar si la propiedad ya existe o no. Si la propiedad no existe, devolverá falso. Si encuentra la propiedad y la elimina, devolverá verdadero.
ayushgp

8

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 .


8

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


7

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.


7

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


SyntaxError: Unexpected token '...'. Expected a property name.?
Krzysztof Przygoda

Pruébelo con un navegador moderno como Firefox, Chromium o Safari. Y espero que también funcione con Edge.
ideaboxer

Como alternativa, si sus clientes lo obligan a admitir navegadores obsoletos, podría considerar usar TypeScript que transpila su código en sintaxis heredada (+ le brinda el beneficio de la seguridad de tipo estático).
ideaboxer

7

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"

var keyname = "KeyName"; eliminar myObject [nombre clave];
Vikash Chauhan

7

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

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

console.log(myObject)
console.log(regex)
console.log(other)


@CoddWrench Lo siento, no presté atención a ver esa respuesta. Respondo inmediatamente después de ver delete myObject.regex;.
xiang

7

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://.*" }

7

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


Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.