it-swarm.com.ru

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

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

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

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

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

Как это:

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

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

7642
nickf

Оператор delete неожиданно медленный!

Посмотрите на тест.

Delete - единственный верный способ удалить свойства объекта без каких-либо остатков, но он работает ~ в 100 раз медленнее , по сравнению с его "альтернативой", установив object[key] = undefined.

Эта альтернатива не является правильным ответом на этот вопрос! Но, если вы используете это с осторожностью, вы можете значительно ускорить некоторые алгоритмы. Если вы используете delete в циклах и у вас проблемы с производительностью, прочтите подробное объяснение.

Когда следует использовать delete и когда установить значение undefined?

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

Используйте delete, , когда вы передаете объект результата в код, над которым у вас нет контроля (или когда вы не уверены в своей команде или сам).

Он удаляет ключ из хэш-карты .

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

Используйте настройку undefined, , когда вы заботитесь о производительности. Это может дать серьезный импульс вашему коду.

Ключ остается на своем месте в хэш-карте , только значение заменяется на undefined. Поймите, что цикл for..in все еще будет повторяться по этому ключу.

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

Используя этот метод, не все способы определения существования свойства будут работать так, как ожидается.

Тем не менее, этот код:

object.field === undefined

будет вести себя одинаково для обоих методов.

Тесты

Подводя итог, можно сказать, что различия заключаются в способах определения существования свойства и в цикле for..in.

 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. *');

Остерегайтесь утечек памяти!

Хотя использование obj[prop] = undefined быстрее, чем delete obj[prop], еще одно важное соображение заключается в том, что obj[prop] = undefined не всегда подходит. delete obj[prop] удаляет prop из obj и стирает его из памяти, тогда как obj[prop] = undefined просто устанавливает значение prop в undefined, что оставляет prop все еще в памяти. Поэтому в ситуациях, когда создается и удаляется много ключей, использование obj[prop] = undefined может привести к дорогостоящему согласованию памяти (вызывая зависание страницы) и, возможно, к ошибке нехватки памяти. Изучите следующий код.

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

В приведенном выше коде простое выполнение nodeRecords[i][lastTime] = undefined; вызовет значительную утечку памяти из-за каждого кадра анимации. Каждый кадр, все 65536 элементов DOM будут занимать еще 65536 отдельных слотов, но для предыдущих 65536 слотов будет установлено только значение undefined, что приведет к их зависанию в памяти. Продолжайте, попробуйте запустить приведенный выше код в консоли и убедитесь сами. После возникновения ошибки нехватки памяти попробуйте запустить ее снова, за исключением следующей версии кода, в которой вместо этого используется оператор delete.

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

Как видно из приведенного выше фрагмента кода, есть несколько редких подходящих вариантов использования оператора delete. Тем не менее, не беспокойтесь об этой проблеме слишком много. Это станет проблемой только для объектов с длительным сроком службы, к которым постоянно добавляются новые ключи. В любом другом случае (который есть почти в каждом случае в программировании реального мира) наиболее целесообразно использовать obj[prop] = undefined. Основная цель этого раздела - просто довести это до вашего сведения, чтобы в редких случаях, когда это становилось проблемой в вашем коде, вы могли легче понять проблему и, таким образом, не тратить часы на разбор кода для поиска и понять эту проблему.

Не всегда установлен на undefined

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

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

Однако с полиморфными массивами есть две основные нерешаемые проблемы:

  1. Они медленные и память неэффективна. При доступе к определенному индексу вместо того, чтобы просто получать глобальный тип для массива, браузер вместо этого должен получать тип на основе индекса, причем каждый индекс хранит дополнительные метаданные своего типа.
  2. Однажды полиморфная, всегда полиморфная. Когда массив становится полиморфным, полиморфизм нельзя отменить в браузерах Webkit. Таким образом, даже если вы восстановите полиморфный массив в неполиморфный, он все равно будет сохранен браузером как полиморфный массив.

Можно сравнить полиморфизм с наркоманией. На первый взгляд, это кажется невероятно прибыльным: хороший, довольно пушистый код. Затем кодер вводит свой массив в препарат полиморфизма. Моментально, полиморфный массив становится менее эффективным, и он никогда не может стать таким же эффективным, как это было раньше, так как он получает наркотики. Чтобы соотнести такое обстоятельство с реальной жизнью, кто-то, употребляющий кокаин, может даже не иметь возможности управлять простой дверной ручкой, а тем более вычислять цифры ПИ. Точно так же массив лекарств от полиморфизма не может быть столь же эффективным, как мономорфный массив.

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

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

Обратите внимание. bar[1] = "" не вызывает полиморфизм, тогда как bar[1] = undefined. Поэтому всегда следует по возможности использовать соответствующий тип для своих объектов, чтобы случайно не вызвать полиморфизм. Один такой человек может использовать следующий список в качестве общего справочника, чтобы заставить их работать. Однако, пожалуйста, не используйте явно приведенные ниже идеи. Вместо этого используйте то, что хорошо работает для вашего кода.

  • При использовании массива/переменной, типизированной логическим примитивом, используйте либо false, либо undefined в качестве пустого значения. Хотя избегать ненужного полиморфизма - это хорошо, переписывание всего кода с явным запретом, скорее всего, приведет к снижению производительности. Используйте здравый смысл!
  • При использовании массива/переменной, типизированной к числовому примитиву, используйте 0 в качестве пустого значения. Обратите внимание, что внутри есть два типа чисел: быстрые целые числа (от 2147483647 до -2147483648 включительно) и медленные двойные числа с плавающей запятой (что угодно, кроме NaN и Infinity). Когда целое число понижается до двойного, оно не может быть преобразовано обратно в целое число.
  • При использовании массива/переменной, типизированной для строкового примитива, используйте "" в качестве пустого значения.
  • При использовании символа, подождите, почему вы используете символ?!?! Символы - это плохая игра для представления. Все, что запрограммировано для использования Символов, может быть перепрограммировано так, чтобы не использовать Символы, в результате чего более быстрый код без Символов. Символы на самом деле просто супер неэффективный мета-сахар.
  • При использовании чего-либо еще используйте null.

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

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

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

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

224
redsquare

Обновление 2018-07-21: В течение долгого времени мне было стыдно за этот ответ, поэтому я думаю, что пришло время немного его подправить. Просто небольшой комментарий, уточнение и форматирование, чтобы помочь ускорить чтение излишне длинных и запутанных частей этого ответа.


КРАТКАЯ ВЕРСИЯ

Актуальный ответ на вопрос

Как уже говорили другие, вы можете использовать delete.

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

Массив эквивалент

Не delete из массива. Вместо этого используйте Array.prototype.splice.

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

Длинная версия

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

В массивах, в отличие от простых старых объектов, использование delete оставляет мусор в виде null, создавая "дыру" в массиве.

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

Как видите, delete не всегда работает так, как можно было ожидать. Значение перезаписывается, но память не перераспределяется. То есть array[4] не перемещен в array[3]. Что отличается от Array.prototype.unshift, который вставляет элемент в начало массива и сдвигает все вверх (array[0] становится array[1] и т.д.)

Честно говоря, помимо установки null, а не undefined--, что на самом деле странно - это поведение не должно быть удивительным, так как delete - унарный оператор как и typeof, который вкрутится в язык и не должен заботиться о типе объекта, на котором он используется, тогда как Array является подкласс Object с методами , специально предназначенными для работы с массивами. Таким образом, у delete нет веских причин для подготовки особого случая для повторного смещения массива, поскольку это просто замедлит работу с ненужной работой. Оглядываясь назад, мои ожидания были нереальными.

Конечно, это удивило . Потому что я написал это, чтобы оправдать свой крестовый поход против "нулевого мусора":

Игнорирование опасностей и проблем, присущих null, и пространства, потраченного впустую, это может быть проблематично, если массив должен быть точным.

Что является ужасным оправданием для того, чтобы избавиться от nulls --null опасно только в случае неправильного использования, и оно не имеет ничего общего с "точностью". Реальная причина, по которой вы не должны delete из массива, состоит в том, что оставление заполненных мусором и грязных структур данных вокруг является небрежным и подверженным ошибкам.

Далее следует довольно сложный сценарий, поэтому вы можете перейти к разделу Решение, если хотите. Единственная причина, по которой я покидаю этот раздел, заключается в том, что я думаю, что некоторые люди, вероятно, считают это смешным, и я не хочу быть "тем парнем", который публикует "смешной" ответ, а затем удаляет из него все "смешные" ,.

... это глупо, я знаю.

Придуманный и затянувшийся сценарий PDP-11

Например, допустим, вы создаете веб-приложение, которое использует JSON-сериализацию для хранения массива, используемого для "вкладок" в строке (в данном случае localStorage). Скажем также, что код использует числовые индексы элементов массива для "заголовка" их при рисовании на экране. Почему вы делаете это, а не просто сохраняете "заголовок"? Потому что ... причины .

Хорошо, давайте просто скажем, что вы пытаетесь сэкономить память по запросу этого одного пользователя, который запускает миникомпьютер PDP-11 из UNIX 1960-х годов и написал свой собственный браузер на основе Elinks, совместимый с JavaScript, поддерживающий линейный принтер, потому что о X11 нет вопроса .

За исключением все более глупого сценария Edge-case, использование delete в указанном массиве приведет к null, приводящему к загрязнению массива, и, вероятно, к более поздним ошибкам в приложении. И если вы проверите для null, он пропустит цифры вверх, в результате чего вкладки будут отображаться как [1] [2] [4] [5] ....

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

Да, это определенно не то, что вы хотели.

Теперь вы можете сохранить второй итератор, например j, для приращения, только когда допустимые значения считываются из массива. Но это не решит проблему null, и вам все равно придется тролль Пользователь PDP-11. Увы, его компьютер просто не имеет достаточно памяти для хранения этого последнего целого числа (не спрашивайте, как ему удается обрабатывать массив переменной ширины ...),.

Итак, он отправляет вам письмо в гневе:

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

Сейчас ты в своем уме. Этот парень без конца жаловался на ваше приложение, и вы хотите сказать ему, чтобы он заткнулся и взял лучший компьютер.

Решение: Array.prototype.splice

К счастью, массивы do имеют специальный метод для удаления индексов и перераспределения памяти: Array.prototype.splice(). Вы могли бы написать что-то вроде этого:

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

И именно так вы порадовали мистера PDP-11. Ура! (Я бы все равно отчитал его, хотя ...)

Array.prototype.splice vs Array.prototype.slice

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

Array.prototype.splice (начало, n)

.splice() мутирует массив и возвращает удаленные индексы. Массив нарезается, начиная с индекса, элементы start и n вырезаны. Если n не указано, весь массив после start будет вырезан (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 (начало, конец)

Функция .slice() является неразрушающей и возвращает новый массив, содержащий указанные индексы, от start до end. Если end не указано, поведение аналогично .splice() (end = array.length). Поведение немного сложнее, так как по какой-то причине end индексирует от 1 вместо 0. Я не знаю, почему это происходит, но так оно и есть. Также, если end <= start, результатом будет пустой массив.

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]

На самом деле это не то, что происходит, но так проще думать. Согласно MDN, вот что на самом деле происходит:

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

Индекс, указанный в end, просто исключается из среза. Индексы в скобках указывают на то, что вырезано. В любом случае, поведение не является интуитивно понятным, и оно неизбежно вызовет значительную долю ошибок "один на один", поэтому может оказаться полезным создать функцию-обертку, чтобы более точно имитировать поведение .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);
}

Обратите внимание, что функция-обертка разработана очень строго к типам и будет возвращать null, если что-то отключено. Это включает в себя добавление строки типа "3". Программист должен быть усердным в своих типах. Это должно поощрять хорошую практику программирования.

Обновление относительно is_array()

Это в отношении этого (теперь удаленного) фрагмента:

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

Как оказалось, на самом деле IS есть встроенный способ узнать, действительно ли массив является массивом, и это Array.isArray(), введенный в ECMAScript 5 (декабрь 2009 г.). Я нашел это, когда смотрел, нет ли вопроса о том, как сказать массивы от объектов, чтобы узнать, есть ли лучшее решение, чем у меня, или добавить мое, если его нет. Так что, если вы используете версию JavaScript, более раннюю, чем ECMA 5, есть ваш polyfill. Однако я настоятельно рекомендую не использовать мою функцию is_array(), поскольку продолжать поддерживать старые версии JavaScript означает продолжать поддерживать старые браузеры, которые их реализуют, что означает поощрение использования небезопасного программного обеспечения и подвергание пользователей риску вредоносного ПО. Поэтому, пожалуйста, используйте Array.isArray(). Используйте let и const. Используйте новые функции, которые добавляются в язык. Не используйте префиксы поставщиков. Удалите это IE с полифиллом с вашего сайта. Удалите эту хрень XHTML <!CDATA[[... - мы перешли на HTML5 еще в 2014 году. Чем раньше все откажутся от поддержки этих старых/эзотерических браузеров, тем скорее производители браузеров фактически последуют веб-стандарту и примут новую технологию, и тем скорее мы может перейти к более безопасной сети.

180
Braden Best

Старый вопрос, современный ответ. Используя деструктуризацию объекта, функцию ECMAScript 6 , это так просто, как:

const { a, ...rest } = { a: 1, b: 2, c: 3 };

Или с образцом вопросов:

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

Вы можете увидеть это в действии в редакторе пробной версии Babel.


Edit:

Чтобы переназначить одну и ту же переменную, используйте let:

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

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

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

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

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

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

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

Ссылка: ссылка _. Опустить (объект, * ключи)

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

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

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

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

87
Thaddeus Albers

Синтаксис распространения (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:
Существует несколько распространенных способов удаления свойства из объекта.
У каждого есть свои плюсы и минусы ( проверьте это сравнение производительности ):

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

delete obj[key];


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

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


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

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

Термин, который вы использовали в заголовке вашего вопроса 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 ()

45
Mehran Hatami

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 (а также оператор удаления ) возвращает 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
38
madox2

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

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 также может испортить вашу индексацию.

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

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

37
John Slegers

оператор удаления - лучший способ сделать это.

Живой пример, чтобы показать:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete

22
Alireza

Другое решение, использующее 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);

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

(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);
20
kind user

Этот пост очень старый, и я нахожу его очень полезным, поэтому я решил поделиться снятой функцией, которую я написал, на тот случай, если кто-то еще увидит этот пост и подумает, почему это не так просто, как в 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"}
19
talsibony

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

Например

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

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

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

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

18
Willem

Используя ES6:

(Разрушение + Оператор распространения)

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

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

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

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

14
Amio.io

Попробуйте следующий метод. Присвойте значение свойства Objectundefined. Затем stringify объект и parse.

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

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

console.log(myObject);
13
Mohammed Safeer

Для клонирования объекта без свойства:

Например:

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

И нам нужно удалить "а".

1. С явным ключом реквизита:

const { a, ...rest } = object;
object = rest;

2.С переменной переменной ключ:

const propKey = 'a';
const { [propKey]: propValue, ...rest } = object;
object = rest;

3. Функция охлаждения стрелки ????:

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

object = removePropery('a', object);

4. Для нескольких свойств

const removeProperties = (object, ...keys) => Object.entries(object).reduce((prev, [key, value]) => ({...prev, ...(!keys.includes(key) && { [key]: value }) }), {})

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

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

или

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

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

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

Пример:

var a = {
    level1:{
        level2:{
            level3: {
                level4: "yolo"
            }
        }
    }
};

deepObjectRemove(a, ["level1", "level2", "level3"]);
console.log(a);

//Prints {level1: {level2: {}}}
11
ayushgp

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

Например:

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

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

delete obj.key1

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

delete obj[key1]

Ссылка: MDN .

7
Kalpesh Patel

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

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

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

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

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

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

Утверждение Дэна о том, что "удаление" очень медленное, и опубликованный им тест были поставлены под сомнение. Поэтому я сам провел тест в 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

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

6
Chong Lip Phang

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

Попробуй это

delete myObject['key'];
5
codemirror

Здравствуйте, вы можете попробовать это просто сортировка

var obj = [];

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

delete(obj.key1);
5
Dhaval Gohel

Удаление недвижимости в JavaScript

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

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

Пропуск свойства покоя на основе строки

Эта категория предназначена для работы с обычными объектами или массивами в более новых разновидностях 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"
4
james_womack

Используя lodash

import omit from 'lodash/omit';

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

Используя Рамду

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

Вы можете использовать ES6 деструктурирование с оператором отдыха.

Свойства могут быть удалены с помощью destructuring в сочетании с оператор rest. В вашем примере регулярное выражение удалено (игнорируется), а остальные свойства возвращаются как остальные.

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

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

Или вы можете динамически исключать свойства, подобные этим,

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

@ johnstock, мы также можем использовать концепцию прототипирования JavaScript, чтобы добавить метод к объектам, чтобы удалить любой переданный ключ, доступный в вызывающем объекте.

Выше ответы приветствуются.

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

// 1st and direct way 
delete myObject.regex;  // delete myObject["regex"]
console.log(myObject); // { ircEvent: 'PRIVMSG', method: 'newURI' }

 // 2 way -  by using the concept of JavaScript's prototyping concept
Object.prototype.removeFromObjectByKey = function(key) {
     // If key exists, remove it and return true
     if(this[key] !== undefined) {
           delete this[key]
           return true;
     }
     // Else return false
     return false;
}

var isRemoved = myObject.removeFromObjectByKey('method')
console.log(myObject)  // { ircEvent: 'PRIVMSG' }

// More examples
var obj = { a: 45, b: 56, c: 67}
console.log(obj) // { a: 45, b: 56, c: 67 }

// Remove key 'a' from obj
isRemoved = obj.removeFromObjectByKey('a')
console.log(isRemoved); //true
console.log(obj); // { b: 56, c: 67 }

// Remove key 'd' from obj which doesn't exist
var isRemoved = obj.removeFromObjectByKey('d')
console.log(isRemoved); // false
console.log(obj); // { b: 56, c: 67 }
3
hygull

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

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

delete myObject.regex;
2
Behnam Mohammadi

вы можете использовать оператор delete как показано ниже.

 var multiverse = {
        earth1: "Silver Age",
        earth2: "Golden Age"
    };

delete multiverse.earth2;//will return true if it finds 

// Outputs: { earth1: "Silver Age" }
console.log(multiverse);

Оператор удаления также имеет return value.. Если ему удастся удалить свойство, он вернет true. Если ему не удастся удалить свойство из-за того, что оно недоступно для записи, оно будет return false или в строгом режиме выдаст ошибку.

1
MANISH MOHAN

Как уже говорили многие, вы можете использовать "delete" (свойство javascript) или "unset" (используя lodash).

Вы также можете использовать свойство lodash "pick", чтобы выбрать только необходимые свойства объекта. Это поможет, когда вам удастся удалить несколько свойств из объекта.

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

var _   = require("lodash");
var obj = {"a":1, "b":2, "c":3};
obj = _.pick(obj,["a","b"]);    
//Now obj contains only 2 props {"a":1, "b":2}
1
Mythili

Я использовал lodash "unset" , чтобы это произошло и для вложенного объекта ... только для этого нужно написать небольшую логику, чтобы получить путь к ключу свойства, ожидаемый методом omit.

  1. Метод, который возвращает путь свойства как массив
var a = {"bool":{"must":[{"range":{"price_index.final_price":{"gt":"450","lt":"500"}}},{"bool":{"should":[{"term":{"color_value.keyword":"Black"}}]}}]}};

function getPathOfKey(object,key,currentPath, t){
     var currentPath = currentPath || [];

    for(var i in object){
                if(i == key){
        t = currentPath;
      }
      else if(typeof object[i] == "object"){
        currentPath.Push(i)
       return getPathOfKey(object[i], key,currentPath)
      }
    }
        t.Push(key);
    return t;
}
document.getElementById("output").innerHTML =JSON.stringify(getPathOfKey(a,"price_index.final_price"))
<div id="output"> 

</div>
  1. Затем просто используя метод lodash unset удалить свойство из объекта.
var unset = require('lodash.unset');
unset(a,getPathOfKey(a,"price_index.final_price"));
1
BEJGAM SHIVA PRASAD
function removeProperty(obj, prop) {
    if(prop in obj){

    Reflect.deleteProperty(obj, prop);
    return true;
   } else {
    return false;
  }
}
1
diayn geogiev

For

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

удалить myObject ["regex"]; Также вы знаете индекс ключа, например. Вам нужно удалить 2-й ключ (регулярное выражение) затем

var key =  Object.keys(myObject)[2]
delete myObject[key];

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

1
RITESH ARORA