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


Digamos que creo un objeto de la siguiente manera:

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

Cuál es la mejor manera de eliminar la propiedad regex para terminar con nuevos myObject ¿como sigue?

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

4893
2017-10-16 10:57


origen


Respuestas:


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 detallada sobre la delete declaración en su blog, Entender borrar. Es altamente recomendado


6817
2017-10-16 10:58



Operador delete es inesperadamente lento!

Mira el punto de referencia.

Eliminar es la única forma verdadera de eliminar las propiedades del objeto sin restos, pero funciona ~ 100 veces más lento, en comparación con su configuración "alternativa" object[key] = undefined.

¡Esta alternativa no es la respuesta correcta a esta pregunta! Pero, si lo usa con cuidado, puede acelerar drásticamente algunos algoritmos. Si estás usando delete en bucles y tiene problemas con el rendimiento, lea la explicación detallada.

Cuándo debería uno usar delete y cuando se establece el valor para undefined ?

Un objeto puede verse como un conjunto de pares clave-valor. Lo que llamo un 'valor' es una primitiva o una referencia a otro objeto, conectado a esa 'clave'.

Utilizar delete, cuando está pasando el objeto de resultado al código en el que no tiene control (o cuando no está seguro acerca de su equipo o usted mismo).

Eso borra la clave del hashmap.

 var obj = {
     field: 1     
 };
 delete obj.field;

Use la configuración para undefined, cuando te importa el rendimiento Puede dar un impulso serio a su código.

los la clave permanece en su lugar en el hashmap, solo el valor se reemplaza con undefined. Entiende eso for..in loop aún se repetirá sobre esa tecla.

 var obj = {
     field: 1     
 };
 obj.field = undefined;

Usando este método, no todos formas de determinar la existencia de la propiedad funcionará como se espera

Sin embargo, este código:

object.field === undefined

se comportará de manera equivalente para ambos métodos.

Pruebas

Para resumir, las diferencias tienen que ver con las formas de determinar la existencia de la propiedad, y sobre for..in lazo.

 console.log('* -> "Takes prototype inheritance into consideration, that means it lookups all over prototype chain too."');

 console.log(obj.field === undefined, 'obj.field === undefined', 'You get "undefined" value when querying for "field" in object-hashmap. *');

 console.log(obj["field"] === undefined, 'obj["field"] === undefined', 'Just another way to query (equivalent). *');

 console.log(typeof obj.field === "undefined", 'typeof obj.field === "undefined"', 'Get the value attached to "field" key, and check it\'s type is "undefined". *');

 console.log("field" in obj, '"field" in obj', 'This statement returns true if "field" key exists in the hashmap. False otherwise. *');

 console.log(obj.hasOwnProperty("field"), 'obj.hasOwnProperty("field")', 'This statement returns true if \'field\' key exists in the hashmap. The ONLY way NOT to lookup for property in the prototype chain!');
 //Object.keys().indexOf() is an overkill that runs much slower :)

 var counter = 0,
     key;
 for (key in obj) {
     counter++;
 }
 console.assert(counter === 0, 'counter === 0', '"field" is not iterated using "for .. in" loop. *');

¡Cuidado con las pérdidas de memoria!

Durante el uso obj[prop] = undefined es más rápido que hacer delete obj[prop], otra consideración importante es que obj[prop] = undefined puede no ser siempre apropiado delete obj[prop] elimina prop de obj y lo borra de la memoria, mientras que obj[prop] = undefined simplemente establece el valor de prop a undefined que deja prop todavía en la memoria. Por lo tanto, en circunstancias en las que se crean y eliminan muchas claves, utilice obj[prop] = undefined puede forzar la costosa reconciliación de la memoria (haciendo que la página se congele) y posiblemente un error de falta de memoria. Examine el siguiente código.

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /*************************************************/
            /****/ nodeRecords[i][lastTime] = undefined; /****/
            /*************************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

En el código anterior, simplemente haciendo nodeRecords[i][lastTime] = undefined; causará una pérdida de memoria masiva debido a que cada cuadro de animación. Cada cuadro, todos los 65536 elementos DOM tomarán otras 65536 ranuras individuales, pero las ranuras 65536 anteriores solo se definirán como indefinidas, lo que las deja colgadas en la memoria. Adelante, intente ejecutar el código anterior en la consola y compruébelo usted mismo. Después de forzar un error de falta de memoria, intente ejecutarlo de nuevo, excepto con la siguiente versión del código que usa el deleteoperador en su lugar.

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /********************************************/
            /****/ delete nodeRecords[i][lastTime]; /****/
            /********************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

Como se ve en el fragmento de código anterior, hay algunos casos de uso poco comunes para el delete operador. Sin embargo, no te preocupes demasiado por este problema. Esto solo se convertirá en un problema con los objetos de larga duración que constantemente les agregan nuevas claves. En cualquier otro caso (que es casi todos los casos en la programación del mundo real), es más apropiado usar obj[prop] = undefined. El propósito principal de esta sección es simplemente llamar su atención para que, en la rara oportunidad de que esto se convierta en un problema en su código, entonces pueda comprender más fácilmente el problema y así no tener que perder horas diseccionando su código para localizar y entiende este problema

No siempre configurado para undefined

Un aspecto de Javascript que es importante considerar es el polimorfismo. El polimorfismo es cuando se asignan los mismos tipos de variable / ranura en un objeto, como se ve a continuación.

var foo = "str";
foo = 100;          // variable foo is now labeled polymorphic by the browser
var bar = ["Some", "example"];
bar[2] = "text";    // bar is a monomorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = undefined; // bar is now a polymorphic array

Sin embargo, hay dos problemas principales no corregibles con matrices polimórficas:

  1. Son lentos y la memoria ineficaz. Al acceder a un índice específico, en lugar de solo obtener el tipo global para la matriz, el navegador debe obtener el tipo en función de cada índice, donde cada índice almacena los metadatos adicionales de su tipo.
  2. Una vez polimórfico, siempre polimórfico. Cuando una matriz se convierte en polimórfica, el polimorfismo no se puede deshacer en los navegadores Webkit. Por lo tanto, incluso si restaura una matriz polimórfica para que no sea polimórfica, el navegador la almacenará como una matriz polimórfica.

Uno puede comparar el polimorfismo con una adicción a las drogas. A primera vista, parece increíblemente lucrativo: bonito código bastante esponjoso. Luego, el codificador introduce su matriz a la droga del polimorfismo. Al instante, la matriz polimórfica se vuelve menos eficiente y nunca puede volverse tan eficiente como lo era antes, ya que está drogada. Para correlacionar tal circunstancia con la vida real, alguien con cocaína podría incluso no ser capaz de operar un simple tirador de puerta, y mucho menos ser capaz de calcular los dígitos de PI. Del mismo modo, una matriz en la droga de polimorfismo nunca puede ser tan eficiente como una matriz monomórfica.

Pero, ¿cómo se relaciona una analogía de viaje de drogas con el delete ¿operación? La respuesta es la última línea de código en el fragmento de arriba. Por lo tanto, que sea reexaminado, esta vez con un giro.

var bar = ["Some", "example"];
bar[2] = "text";    // bar is not a polymorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = "";        // bar is still a monomorphic array
bar[1] = undefined; // bar is now a polymorphic array

Observar. bar[1] = "" no coacciona el polimorfismo mientras bar[1] = undefined hace. Por lo tanto, siempre se debe, siempre que sea posible, usar el tipo correspondiente para sus objetos a fin de no causar polimorfismo accidentalmente. Una de esas personas puede usar la siguiente lista como referencia general para ponerlas en marcha. Sin embargo, no use explícitamente las ideas a continuación. En su lugar, use lo que funcione bien para su código.

  • Al usar una matriz / variable escrita a la primitiva booleana, use cualquiera false o undefined como el valor vacío Aunque es bueno evitar el polimorfismo innecesario, reescribir todo el código para prohibirlo explícitamente probablemente dé como resultado una disminución en el rendimiento. ¡Usa el juicio común!
  • Al usar una matriz / variable escrita a la primitiva del número, use 0 como el valor vacío Tenga en cuenta que internamente, hay dos tipos de números: enteros rápidos (2147483647 a -2147483648 inclusive) y dobles de punto flotante lentos (cualquier cosa que no sea eso incluido NaN y Infinity) Cuando un entero se degrada a un doble, no se puede volver a promocionar a un número entero.
  • Al usar una matriz / variable escrita a la primitiva de cadena, use "" como el valor vacío
  • Al usar un símbolo, espere, ¿por qué está usando un símbolo?!?! Los símbolos son malos juju para el rendimiento. Todo lo programado para usar Símbolos se puede reprogramar para que no use Símbolos, lo que da como resultado un código más rápido sin Símbolos. Los símbolos son en realidad un meta-azúcar super ineficiente.
  • Cuando use cualquier otra cosa, use null.

Sin embargo, ¡ten cuidado! No empieces a hacer esto de repente con todos tus códigos preexistentes, ya que es probable que rompa ese código preexistente y / o que introduzcas errores extraños. Por el contrario, una práctica tan eficiente debe implementarse desde el principio, y al convertir el código preexistente, se recomienda duplicar, triplicar, cuadriplicar todas las líneas relacionadas con eso, ya que tratar de actualizar el código anterior a esta nueva práctica puede ser tan arriesgado, ya que es gratificante.


700
2018-02-12 17:48



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.


192
2017-10-16 11:03



Actualización 2018-07-21: Durante mucho tiempo, me sentí avergonzado por esta respuesta, así que creo que es hora de que la retoque un poco. Solo un pequeño comentario, aclaración y formato para ayudar a acelerar la lectura de las partes innecesariamente largas y enrevesadas de esta respuesta.


LA VERSIÓN CORTA

La respuesta real a la pregunta

Como otros han dicho, puedes usar delete.

obj // {"foo": "bar"}
delete obj["foo"]
obj // {}
obj["foo"] // undefined

Matriz equivalente

No lo hagas delete de una matriz. Utilizar Array.prototype.splice en lugar.

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

LA VERSIÓN LARGA

JavaScript es un lenguaje OOP, entonces todo es un objeto, incluyendo matrices. Por lo tanto, siento que es necesario señalar una advertencia en particular.

En matrices, a diferencia de objetos antiguos simples, usando delete deja atrás la basura en forma de null, creando un "agujero" en la matriz.

var array = [1, 2, 3, 4];
delete array[2];
/* Expected result --> [1, 2, 4]
 * Actual result   --> [1, 2, null, 4]
 */

Como puedes ver, delete no siempre funciona como uno podría esperar El valor se sobrescribe, pero la memoria no se reasigna. Es decir, array[4] no se reubica a array[3]. Lo cual está en contraste con Array.prototype.unshift, que inserta un elemento al principio de la matriz y lo cambia todo (array[0] se convierte array[1], etc.)

Honestamente, aparte de establecer a null más bien que undefined- que es legítimamente raro - este comportamiento no debería ser sorprendente, ya que delete es un operador unario, como typeof, eso es difícil en el lenguaje y no se supone que se preocupe por el tipo del objeto en el que se está utilizando, mientras que Array es una subclase de Object con métodos específicamente diseñado para trabajando con arreglos. Entonces no hay una buena razón para deletetener un caso especial cocinado para volver a cambiar la matriz, ya que eso simplemente ralentizaría las cosas con un trabajo innecesario. En retrospectiva, mis expectativas eran poco realistas.

Por supuesto, hizo Sorpréndeme. Porque escribí esto para justificar mi cruzada contra la "basura nula":

Ignorando los peligros y problemas inherentes a null, y el espacio desperdiciado, esto puede ser problemático si la matriz necesita ser precisa.

Que es una terrible justificación para deshacerse de la nulls--null solo es peligroso si se usa incorrectamente, y no tiene nada que ver con "precisión". La verdadera razón por la que no deberías delete de una matriz es porque dejar estructuras de datos llenas de basura y desordenadas es descuidado y propenso a errores.

Lo que sigue es un escenario inventado que se vuelve bastante largo, por lo que puede saltar a la sección, La solución, si tu quieres. La única razón por la que dejo esta sección es porque creo que algunas personas probablemente piensan que es gracioso, y no quiero ser "ese tipo" que publica una respuesta "divertida" y luego borra todo lo "divertido" de ella más adelante. .

... Es estúpido, lo sé.

El escenario artificial y largo de PDP-11

Por ejemplo, supongamos que está creando una aplicación web que usa la serialización JSON para almacenar una matriz utilizada para 'pestañas' en una cadena (en este caso, localStorage) Digamos también que el código usa los índices numéricos de los miembros de la matriz para "titularlos" al dibujar en la pantalla. ¿Por qué estás haciendo esto en lugar de solo almacenar el "título" también? Porque... razones.

De acuerdo, digamos que estás tratando de guardar memoria a petición de este uno usuario que ejecuta un miniordenador PDP-11 de la década de 1960 que ejecuta UNIX, y escribió su propio navegador basado en Elinks, compatible con las impresoras de línea, JavaScript porque X11 es fuera de la cuestión.

Escenario de caso marginal cada vez más estúpido a un lado, usando delete en dicha matriz dará lugar a null contaminando la matriz, y probablemente causando errores en la aplicación más adelante. Y si busca null, saltaría directamente los números y las pestañas se mostrarían como [1] [2] [4] [5] ....

if (array[index] == null)
    continue;
else
    title = (index + 1).toString();
/* 0 -> "1"
 * 1 -> "2"
 * 2 -> (nothing)
 * 3 -> "4"
 */

Sí, eso definitivamente no es lo que querías.

Ahora tu podría mantener un segundo iterador, como j, para incrementar solo cuando se leen valores válidos de la matriz. Pero eso no resolvería exactamente el null problema, y ​​aún tienes que agradar Troll Usuario PDP-11. Por desgracia, su computadora solo no lo hace tener suficiente memoria para mantener ese último entero (No preguntes cómo se las arregla para manejar una matriz de ancho variable ...).

Entonces, él te envía un correo electrónico enojado:

Hey, your webapp broke my browser! I checked my localStorage database after your stupid code made my browser segfault, and this is what I found:

>"tabs:['Hello World', 'foo bar baz', null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, ... ]"

After clearing my precious data, it segfaulted again, and I did a backtrace, and what do I find? WHAT DO I FIND!? YOU USE TOO MANY VARIABLES!

>var i = index;
>var j = 1;

Grr, I am angry now.
-Troll Davidson

Hasta ahora, estás al final de tu ingenio. Este tipo se ha estado quejando sin parar sobre su aplicación, y quiere decirle que se calle e intente obtener una mejor computadora.

La solución: Array.prototype.splice

Afortunadamente, matrices hacer tener un método especializado para borrar índices y reasignar memoria: Array.prototype.splice(). Podrías escribir algo como esto:

Array.prototype.remove = function(index){
  this.splice(index,1);
}
...
array = [1, 2, 3, 4];
array.remove(2);
// Result -> [1, 2, 4]

Y así, has complacido al Sr. PDP-11. ¡Hurra! (Aún así lo contaría, aunque ...)

Array.prototype.splice vs Array.prototype.slice

Creo que es importante señalar la diferencia entre estas dos funciones con nombres similares, ya que ambas son muy útiles.

Array.prototype.splice (inicio, n)

.splice() muta la matriz y devuelve los índices eliminados. La matriz se divide a partir del índice, starty n los elementos se cortan. Si n no se especifica, toda la matriz después start se corta en rodajas (n = array.length - start)

let a = [5,4,3,2,1];
let chunk = a.splice(2,2);

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

chunk; // [3,2]
a;     // [5,4,1]

Array.prototype.slice (inicio, fin)

.slice() es no destructivo y devuelve una nueva matriz que contiene los índices indicados de start a end. Si end queda sin especificar, el comportamiento es el mismo que .splice() (end = array.length) El comportamiento es un poco complicado ya que, por alguna razón, end índices de 1 en lugar de 0. No sé por qué lo hace, pero así son las cosas. También si end <= start, el resultado es una matriz vacía.

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

// a             [5,4,3,2,1]
// start          0 1 2 - -
// end, for...    - - - - -
//   chunks[0]  0 - - - - -   
//   chunks[1]    1 2 - - -
//   chunks[2]    1 2 3 - -
//   chunks[3]    1 2 3 4 5

chunks; // [ [], [], [3], [3,2,1] ]
a;      // [5,4,3,2,1]

Eso en realidad no es lo que está sucediendo, pero es más fácil pensar de esa manera. Según MDN, esto es lo que está sucediendo realmente:

// a             [5,4,3,2,1]
// start          0 1 2 - - -
// end, for...    - - - - - -
//   chunks[0]    0 - - - - -
//   chunks[1]    0 1 2 - - -
//   chunks[2]    0 1(2)3 - -
//   chunks[3]    0 1(2 3 4)5

El índice especificado por end simplemente se excluye de la porción. Los índices entre paréntesis indican qué se corta. De cualquier manera, el comportamiento no es intuitivo y es probable que cause su parte justa de errores uno a uno, por lo que puede resultarle útil hacer una función de envoltura para emular más de cerca el comportamiento de .splice():

function ez_slice(array, start = 0, n = null){
    if(!Array.isArray(array) || !is_number(start))
        return null;

    if(is_number(n))
        return array.slice(start, start + n);

    if(n === null)
        return array.slice(start);

    return null;
}

ez_slice([5,4,3,2,1], 2, 1) // [3]
ez_slice([5,4,3,2,1], 2)    // [3,2,1]

/* Fun fact: isNaN is unreliable.
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(isNaN)
 * [NaN, {}, undefined, "Hi"]
 *
 * What we want is...
 *
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(is_nan)
 * [NaN]
 */
function is_nan(num){
    return typeof num === "number"
        && num !== num;
}

function is_number(num){
    return !is_nan(num)
        && typeof num === "number"
        && isFinite(num);
}

Tenga en cuenta que la función de envoltura está diseñada para ser muy estricta con los tipos y que devolverá null si algo está apagado. Eso incluye poner una cuerda como "3". Depende del programador ser diligente con sus tipos. Esto es para fomentar buenas prácticas de programación.

Actualización sobre is_array()

Esto es con respecto a este fragmento (ahora eliminado):

function is_array(array){
    return array !== null
        && typeof array === "object"
        && typeof array.length !== "undefined"
        && array.__proto__ === Array.prototype;
}

Entonces, resulta que realmente hay una forma incorporada de decir si una matriz es realmente una matriz, y eso es Array.isArray(), presentado en ECMAScript 5 (diciembre de 2009). Encontré esto mientras miraba si había una pregunta que me preguntaba sobre cómo contar las matrices de los objetos, para ver si había una solución mejor que la mía, o para agregar la mía si no había ninguna. Entonces, si está utilizando una versión de JavaScript que es anterior a ECMA 5, está su relleno policrible. Sin embargo, recomiendo no usar mi is_array() función, ya que continuar respaldando las versiones anteriores de JavaScript significa continuar apoyando a los navegadores antiguos que las implementan, lo que significa fomentar el uso de software inseguro y poner a los usuarios en riesgo de malware. Entonces, por favor, usa Array.isArray(). Utilizar let y const. Use las nuevas funciones que se agregan al idioma. No lo hagas use los prefijos del vendedor. Borrar que IE basura de polyfill de su sitio web. Eliminar ese XHTML <!CDATA[[... basura, también, nos mudamos a HTML5 en 2014. Cuanto antes todo el mundo retire el soporte para esos navegadores antiguos / esotéricos, antes los proveedores de navegadores seguirán el estándar web y aceptarán la nueva tecnología, y antes podremos pasar a una web más segura.


133
2017-09-18 00:56



Vieja pregunta, respuesta moderna. Usando la desestructuración de objetos, ECMAScript 6 función, 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 un let:

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

91
2017-11-08 18:02



Otra alternativa es usar el Underscore.js biblioteca.

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

Referencia: enlazar  _.pick (objeto, * claves)

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

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

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

Referencia: enlazar  _.omit (objeto, * claves)

Devuelve una copia del objeto, filtrada para omitir el llaves en la lista negra (o conjunto de llaves).

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

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

Para arreglos, _.filter() y _.reject() se puede usar de manera similar.


65
2018-05-24 18:53



El término que ha usado en su título de pregunta Remove a property from a JavaScript object, puede ser interpretado de diferentes maneras. Uno es eliminarlo para toda la memoria y la lista de teclas de objeto o la otra es simplemente para eliminarlo de su objeto. Como se ha mencionado en algunas otras respuestas, el delete palabra clave es la parte principal. Digamos que tiene su 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 objetos como:

delete myJSONObject["regex"];

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

["ircEvent", "method"]

Pero el punto es que si le importa la memoria y desea que todo el objeto se elimine de la memoria, se recomienda establecerlo 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"];

Entonces, incluso si lo quitas de tu objeto myJSONObject, ese objeto específico no se eliminará de la memoria, ya que el regex variable 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 borra todas las referencias que tienes en tu código, apunta a ese mismo objeto y también No utilice var declaraciones para crear nuevas referencias a ese objeto. Este último punto con respecto a var declaraciones, es uno de los problemas más cruciales con los que nos enfrentamos habitualmente, porque var las declaraciones evitarían que el objeto creado sea eliminado.

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

delete regex; //False

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

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

En otras palabras, un objeto JavaScript se destruye tan pronto como no haya referencia en el código apuntando a ese objeto.


Actualizar: Gracias a @AgentME:

Establecer una propiedad en nulo antes de eliminarlo no logra   cualquier cosa (a menos que el objeto haya sido sellado por Object.seal y el   Eliminar falla. Ese no suele ser el caso a menos que específicamente   tratar).

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


33
2018-02-12 06:29



ECMAScript 2015 (o ES6) vino con un built-in Reflejar objeto. Es posible eliminar la propiedad del objeto llamando Reflect.deleteProperty () Funciona con objeto objetivo y clave de propiedad como parámetros:

Reflect.deleteProperty(myJSONObject, 'regex');

que es equivalente a:

delete myJSONObject['regex'];

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

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

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

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

"use strict";

let obj = Object.freeze({ prop: "value" });
Reflect.deleteProperty(obj, "prop"); // false
delete obj["prop"];
// TypeError: property "prop" is non-configurable and can't be deleted

28
2018-01-10 16:36



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 quieres usar la totalidad staff array, la forma correcta de hacerlo, sería hacer esto:

delete Hogwarts.staff;

Alternativamente, también puedes hacer esto:

delete Hogwarts['staff'];

Del mismo modo, eliminar toda la matriz de estudiantes se haría llamando delete Hogwarts.students; o delete Hogwarts['students'];.

Eliminar un índice de matriz

Ahora, si desea eliminar un miembro del personal o un alumno, el procedimiento es un poco diferente, porque ambas propiedades son matrices.

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

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

Por lo tanto, al eliminar valores de un objeto, siempre primero considere 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 violín como punto de partida


28
2018-02-21 18:09