javascript-objects удаление - Как удалить свойство из объекта JavaScript?




добавить массив (25)

Скажем, я создаю объект следующим образом:

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

Каков наилучший способ удалить свойство regex чтобы в итоге получить новый myObject следующим образом?

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

Answers

Очень просто:

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

delete myObject.regex;

Использование ES6:

(Оператор Destructuring + Spread)

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

2 (ES6)

Тем, кому это нужно ...

Чтобы завершить ответ @Koen в этом потоке, если вы хотите удалить динамическую переменную с помощью синтаксиса распространения, вы можете сделать это следующим образом:

const key = 'a';

const { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 };

console.log(rest); // { b: 2, c: 3 }

* fooбудет новой переменной со значением a(которое равно 1).


UPDATE :
Существует несколько способов удаления свойства из объекта.
У каждого есть свои плюсы и минусы ( проверьте это сравнение производительности ):

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Читаемый и короткий, однако это может быть не лучший выбор, если вы работаете с большим количеством объектов, так как его производительность не оптимизирована.

delete obj[key];


Reassignment
Более чем на 2 раза быстрее, чемdeleteсвойствонеудаляется и может быть повторено.

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


Spread Operator
ЭтотES6оператор позволяет нам вернуть совершенно новый объект, исключая любые свойства, без изменения существующего объекта. Недостатком является то, что он имеет худшую производительность из вышеперечисленного и не предлагается использовать, когда вам нужно удалить сразу несколько свойств.

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

Попробуйте следующий метод. Назначьте Objectзначение свойства undefined. Тогда stringifyобъект и parse.

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

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

console.log(myObject);


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

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

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


Использование lodash

import omit from 'lodash/omit';

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

Использование Ramda

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

Предположим, у вас есть объект, который выглядит так:

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

Удаление свойства объекта

Если вы хотите использовать весь staffмассив, правильный способ сделать это:

delete Hogwarts.staff;

Кроме того, вы также можете сделать это:

delete Hogwarts['staff'];

Аналогично, удаление всего массива студентов будет выполняться путем вызова delete Hogwarts.students;илиdelete Hogwarts['students']; ,

Удаление индекса массива

Теперь, если вы хотите удалить одного сотрудника или ученика, процедура немного отличается, поскольку оба свойства являются самими массивами.

Если вы знаете индекс своего сотрудника, вы можете просто сделать это:

Hogwarts.staff.splice(3, 1);

Если вы не знаете индекс, вам также понадобится выполнить поиск по индексу:

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

Заметка

Хотя вы технически можете использовать deleteдля массива, использование его приведет к получению неверных результатов при вызове, например, Hogwarts.staff.lengthпозже. Другими словами, deleteудалите элемент, но он не обновит значение lengthсвойства. Использование deleteтакже испортило бы вашу индексацию.

Таким образом, при удалении значений из объекта всегда сначала учитывайте, имеете ли вы дело с свойствами объекта или имеете ли вы значения массива, и выбирайте на основе этого соответствующую стратегию.

Если вы хотите поэкспериментировать с этим, вы можете использовать этот скрипт в качестве отправной точки.


Удаление имущества в JavaScript

На этой странице представлено множество различных вариантов, а не потому, что большинство вариантов неверны, или потому, что ответы являются дубликатами, а потому, что соответствующий метод зависит от ситуации, в которой вы находитесь, и целей задач, которые вы и / или вы команда пытается выполнить. Чтобы ответить на ваш вопрос однозначно, нужно знать:

  1. Версия ECMAScript, на которую вы нацеливаетесь
  2. Диапазон типов объектов, которые вы хотите удалить, и типы имен свойств, которые вам нужно упускать (только строки) Символы? Слабые ссылки, сопоставленные с произвольными объектами? Все это были типы указателей свойств в JavaScript уже много лет )
  3. Этимы / шаблоны программирования, которые вы и ваша команда используете. Поддерживаете ли вы функциональные подходы, а мутация - в вашей команде, или вы используете дикие западные мутативные объектно-ориентированные методы?
  4. Вы хотите добиться этого в чистом JavaScript или хотите ли вы использовать стороннюю библиотеку?

После ответа на эти четыре вопроса в JavaScript есть по существу четыре категории «удаление собственности» на JavaScript, чтобы соответствовать вашим целям. Они есть:

Удаление мутативного объекта, небезопасное

Эта категория предназначена для работы с объектными литералами или экземплярами объектов, когда вы хотите сохранить / продолжить использовать исходную ссылку и не используете в своем коде функциональные принципы без состояния. Пример синтаксиса в этой категории:

'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

Эта категория является самой старой, самой простой и наиболее широко распространенной категорией удаления собственности. Он поддерживает Symbolи индексы массивов в дополнение к строкам и работает в каждой версии JavaScript, за исключением самой первой версии. Однако это мутация, которая нарушает некоторые принципы программирования и имеет последствия для производительности. Это также может привести к неперехваченным исключениям при использовании в developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .

Исключение свойств строки на основе Rest

Эта категория предназначена для работы с экземплярами простого объекта или массива в новых вариантах ECMAScript, когда требуется не-мутирующий подход, и вам не нужно учитывать ключи Symbol:

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

Удаление мутативного объекта, безопасное

Эта категория предназначена для работы с объектными литералами или экземплярами объектов, когда вы хотите сохранить / продолжать использовать исходную ссылку, защищая от исключений, возникающих при неконфигурируемых свойствах:

'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

Кроме того, в то время как мутирующие объекты на месте не являются апатридами, вы можете использовать функциональный характер Reflect.deletePropertyдля частичного применения и других функциональных методов, которые невозможны для deleteоператоров.

Бездействие на основе синтаксиса

Эта категория предназначена для работы с экземплярами простого объекта или массива в новых вариантах ECMAScript, когда требуется не-мутирующий подход, и вам не нужно учитывать ключи Symbol:

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

Исключение имущества на базе библиотеки

Эта категория, как правило, обеспечивает большую функциональную гибкость, включая учет символов и исключение более одного свойства в одном заявлении:

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"

Этот пост очень старый, и я нахожу его очень полезным, поэтому я решил поделиться отключенной функцией, которую я написал, в случае, если кто-то еще увидит этот пост и подумает, почему это не так просто, как в функции отмены PHP.

Причиной написания этой новой unsetфункции является сохранение индекса всех других переменных в этом hash_map. Посмотрите на следующий пример и посмотрите, как индекс «test2» не изменился после удаления значения из 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"}

Другой альтернативой является использование библиотеки Underscore.js .

Обратите внимание, что _.pick() и _.omit() возвращают копию объекта и не изменяют напрямую оригинальный объект. Присвоение результата исходному объекту должно выполнить трюк (не показан).

Ссылка: link _.pick (объект, * ключи)

Вернуть копию объекта, отфильтровать, чтобы иметь только значения для белых ключей (или массива действительных ключей).

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

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

Ссылка: link _.omit (объект, * ключи)

Верните копию объекта, отфильтрованную, чтобы опустить вложенные в черный список ключи (или массив ключей).

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

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

Для массивов, _.filter() и _.reject() могут использоваться аналогичным образом.


Привет, Вы можете попробовать этот простой вид

var obj = [];

obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};

delete(obj.key1);

Рассмотрите возможность создания нового объекта без "regex"свойства, потому что исходный объект всегда может ссылаться на другие части вашей программы. Таким образом, вам следует избегать манипулирования им.

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

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

console.log(newMyObject);


Термин, который вы использовали в заголовке вопроса. Remove a property from a JavaScript object , можно интерпретировать по-разному. Один из них заключается в том, чтобы удалить его для всей памяти, а список объектных ключей или другой - просто удалить его из вашего объекта. Как уже упоминалось в некоторых других ответах, ключевое слово delete является основной. Допустим, у вас есть свой объект:

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

Если вы это сделаете:

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

результатом будет:

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

Вы можете удалить этот конкретный ключ из ваших объектных ключей, например:

delete myJSONObject["regex"];

Тогда ваш ключ объектов с помощью Object.keys(myJSONObject) будет выглядеть следующим образом:

["ircEvent", "method"]

Но дело в том, что если вы заботитесь о памяти и хотите, чтобы весь объект удалялся из памяти, рекомендуется установить его значение null до того, как вы удалите ключ:

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

Другим важным моментом здесь является осторожность в отношении ваших других ссылок на один и тот же объект. Например, если вы создаете переменную типа:

var regex = myJSONObject["regex"];

Или добавьте его как новый указатель на другой объект, например:

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

Тогда даже если вы удалите его из объекта myJSONObject , этот конкретный объект не будет удален из памяти, так как переменная regex и myOtherObject["regex"] все еще имеют свои значения. Тогда как мы могли бы точно удалить объект из памяти?

Ответ должен был бы удалить все ссылки, которые у вас есть в вашем коде, указал на этот самый объект, а также не использовать инструкции var для создания новых ссылок на этот объект . Этот последний пункт, касающийся операторов var , является одной из наиболее важных проблем, с которыми мы обычно сталкиваемся, поскольку использование операторов var препятствует удалению созданного объекта.

Это означает, что в этом случае вы не сможете удалить этот объект, потому что вы создали переменную regex помощью инструкции var , и если вы это сделаете:

delete regex; //False

Результат будет false , что означает, что ваш оператор delete не был выполнен, как вы ожидали. Но если вы еще не создали эту переменную раньше, и вы только что использовали myOtherObject["regex"] качестве вашей последней существующей ссылки, вы могли бы сделать это, просто удалив ее так:

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

Другими словами, объект JavaScript будет убит, как только в коде не будет указана ссылка на этот объект.

Обновление: благодаря @AgentME:

Установка свойства null перед удалением не выполняет ничего (если объект не был закрыт объектом Object.seal, и удаление завершилось неудачно. Обычно это не так, если вы специально не попытаетесь).

Чтобы получить дополнительную информацию об Object.seal : Object.seal()


Использование метода удаления - лучший способ сделать это, согласно описанию MDN, оператор delete удаляет свойство из объекта. Поэтому вы можете просто написать:

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

Оператор delete удаляет заданное свойство из объекта. При успешном удалении оно вернет true, иначе будет возвращено false. Однако важно учитывать следующие сценарии:

  • Если свойство, которое вы пытаетесь удалить, не существует, delete не будет иметь никакого эффекта и вернет true

  • Если свойство с таким же именем существует в цепочке прототипов объекта, то после удаления объект будет использовать свойство из цепи прототипа (другими словами, удаление только влияет на собственные свойства).

  • Любое свойство, объявленное с помощью var, не может быть удалено из глобальной области действия или из области действия.

  • Таким образом, delete не может удалить какие-либо функции в глобальной области (независимо от того, является ли это частью определения функции или функции (выражение).

  • Функции, которые являются частью объекта (кроме
    глобальной области), могут быть удалены с удалением.

  • Любое свойство, объявленное с let или const, не может быть удалено из области действия, в которой они были определены. Неконфигурируемые свойства не могут быть удалены. Сюда входят свойства встроенных объектов, таких как Math, Array, Object и свойства, которые создаются как неконфигурируемые с помощью методов Object.defineProperty ().

Следующий фрагмент дает еще один простой пример:

var Employee = {
      age: 28,
      name: 'abc',
      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

Для получения дополнительной информации и получения более подробной информации посетите приведенную ниже ссылку:

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…


Как это:

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

демонстрация

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

console.log(myObject);

Для всех, кто интересуется чтением об этом, пользователь kangax написал невероятно подробное сообщение в блоге об объявлении delete в своем блоге « Понимание удаления» . Настоятельно рекомендуется.


Здесь есть много хороших ответов, но я просто хочу услышать, что при использовании delete для удаления свойства в JavaScript часто бывает полезно сначала проверить, существует ли это свойство для предотвращения ошибок.

Например

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

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

Из-за динамического характера JavaScript часто случаются случаи, когда вы просто не знаете, существует ли свойство или нет. Проверка существования obj перед && также гарантирует, что вы не выкидываете ошибку из-за вызова функции hasOwnProperty () на неопределенный объект.

Извините, если это не добавило вашего конкретного варианта использования, но я считаю, что это хороший дизайн для адаптации при управлении объектами и их свойствами.


Вы можете просто удалить любое свойство объекта, используя deleteключевое слово.

Например:

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

Чтобы удалить любое свойство, скажем key1, используйте deleteключевое слово:

delete obj.key1

Или вы также можете использовать массивную нотацию:

delete obj[key1]

Ссылка: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .


ECMAScript 2015 (или ES6) поставляется со встроенным объектом Reflect . Можно удалить свойство объекта, вызвав Reflect.deleteProperty() с целевым объектом и ключом свойства в качестве параметров:

Reflect.deleteProperty(myJSONObject, 'regex');

что эквивалентно:

delete myJSONObject['regex'];

Но если свойство объекта не настраивается, его нельзя удалить ни с помощью функции deleteProperty, ни с оператора delete:

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

Object.freeze() делает все свойства объекта не настраиваемыми (помимо прочего). deletePropertyфункция (а также developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… ) возвращается falseпри попытке удалить любые ее свойства. Если свойство настраивается, оно возвращается true, даже если свойство не существует.

Разница между deleteи deletePropertyзаключается в использовании строгого режима:

"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

Object.assign () & Object.keys () & 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"];
        }
    }
);



Используя ramda#dissoc вы получите новый объект без атрибута regex:

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

Вы также можете использовать другие функции для достижения того же эффекта - пропустить, выбрать, ...


Утверждение Дэна о том, что «удаление» происходит очень медленно, и поставленный в нем тест был усомнился. Поэтому я сам проверил тест в Chrome 59. Кажется, что «delete» примерно в 30 раз медленнее:

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

Обратите внимание, что я специально выполнял несколько операций удаления в одном цикле цикла, чтобы минимизировать эффект, вызванный другими операциями.


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

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

Это работает в Firefox и Internet Explorer, и я думаю, что это работает во всех остальных.


Я лично использую Underscore.js для манипулирования объектами и массивами:

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

если вы пытаетесь получить только элементы, но не функции, то этот код может помочь вам

this.getKeys = function() {

    var keys = new Array();
    for(var key in this) {

        if( typeof this[key] !== 'function') {

            keys.push(key);
        }
    }
    return keys;
}

это часть моей реализации HashMap, и мне нужны только ключи, «это» - это объект hashmap, содержащий ключи





javascript javascript-objects object-properties