38 Вопрос: Как удалить свойство из объекта JavaScript?

вопрос создан в Sun, Feb 19, 2017 12:00 AM

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

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

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

 
var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI"
};
    
5583
  1. Найдите здесь эталонный тест, который сравнивает "delete" и "undefined" с "null" jsben.ch /# /BWMiw
    2017-03-06 11: 31: 56Z
  2. 2017-11-15 15: 35: 26Z
30 ответов                              30                         

Вот так:

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

Demo

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

console.log(myObject);

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

    
7655
2017-10-09 16: 55: 56Z
  1. Проверено, он также работает с "delete myJSONObject ['regex'];" См. developer.mozilla.org/en/Core_JavaScript_1.5_Reference/…
    2008-10-16 11: 06: 42Z
  2. Результатом одного из наблюдений по приведенной выше ссылке "понимание удаления" является то, что, поскольку вы не обязательно можете удалить переменную, а только свойства объекта, вы не сможете удалить свойство объекта "по ссылке" - var value = obj ['prop']; удалить значение //не работает
    2010-04-16 16: 24: 33Z
  3. То есть он не удаляется? Это просто становится неопределенным, но ключ все еще существует? Я что-то упустил?
    2011-08-10 02: 21: 35Z
  4. @ Пит нет, он действительно удаляется. Дано: var x = {a : 'A', b : 'B'}; Сравнить: с delete x.a; typeof x.a; /* "undefined" */ x.hasOwnProperty('a'); /* false */ по x.b = undefined; typeof x.b; /* "undefined" */; x.hasOwnProperty('b'); /* true */
    2011-08-10 08: 29: 19Z
  5. @ ChristopherPfohl работает для меня. Как я уже сказал, на самом деле это довольно глубоко, поэтому подвести итог немного сложно. Основной ответ в ответе выше достаточен почти для всех случаев, в блоге рассматриваются еще некоторые крайние случаи и причины, по которым эти случаи существуют.
    2012-12-20 01: 57: 12Z

Оператор 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). Когда целое число понижается до двойного, оно не может быть преобразовано обратно в целое число.
  • При использовании массива /переменной, типизированной для строкового примитива, используйте "" в качестве пустого значения.
  • При использовании Symbol подождите, почему вы используете Symbol?!?! Символы - это плохая игра для представления. Все, что запрограммировано для использования Символов, может быть перепрограммировано так, чтобы не использовать Символы, в результате чего более быстрый код без Символов. Символы на самом деле просто супер неэффективный мета-сахар.
  • При использовании чего-либо еще используйте null.

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

    
826
2018-04-19 10: 26: 30Z
  1. свойство, назначенное неопределенному, все еще является свойством объекта, поэтому оно не будет удалено GC, если не будет неправильно прочитан ваш последний абзац.
    2014-03-04 21: 05: 54Z
  2. Я ошибся, коснувшись темы GC здесь. Оба метода имеют одинаковый результат для GC: они удаляют значение, связанное с ключом. Если это значение было последней ссылкой на какой-либо другой объект, этот объект был бы очищен.
    2014-03-06 10: 28: 46Z
  3. свойство, назначенное неопределенному, все еще является свойством объекта, поэтому оно не будет удалено GC GC не управляет что-нибудь о свойствах. Он собирает и удаляет значения. Пока ничто больше не ссылается на значение (объект, строку и т. Д.), GC действительно удаляет его из памяти.
    2014-07-16 15: 03: 18Z
  4. Кстати, это двойная проблема, чтобы проверить, существует ли свойство в объекте Javascript. Использование оператора in надежно, но медленно. Проверьте, не является ли свойство undefined «неправильным ответом», но оно намного быстрее. check
    2014-11-03 17: 32: 30Z
  5. Этот ответ по-прежнему актуален? jsperf в настоящее время не работает, но этот тест , похоже, указывает на то, что разница в скорости составляет всего 25%, что нигде не близко к "~ 100 раз медленнее" в этом ответе.
    2016-12-14 08: 29: 46Z

р>

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

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

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

    
224
2018-06-01 16: 29: 50Z

Обновление 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 - это язык ООП, поэтому все является объектом, включая массивы . Таким образом, я считаю необходимым указать конкретную оговорку.

В массивах, в отличие от простых старых объектов, использование 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, и пространства, потраченного впустую, это может быть проблематично, если массив должен быть точным.

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

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

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

Придуманный и многословный сценарий PDP-11

  

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

     

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

     

За исключением все более и более глупого сценария с крайним регистром, использование 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 (start, 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;
}

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

    
182
2019-04-27 03: 47: 41Z
  1. Это ключевое слово delete, однако, гораздо удобнее, lol
    2012-09-18 00: 59: 47Z
  2. Этот подход не изменяет исходный объект, на который все еще можно ссылаться в другом месте. Это может или не может быть проблемой в зависимости от того, как это используется, но об этом нужно помнить.
    2012-11-07 17: 39: 59Z
  3. @ B1KMusic Вот способ удаления элемента из массива: splice
    2013-01-25 20: 20: 43Z
  4. @ wulftone nope, который разбивает массив и ничего не делает для удаления значения. Я действительно считаю, что лучший способ удаления из массива, в котором необходимо удалить определенные значения, - это использовать delete и создать для этого функцию сбора мусора.
    2013-01-26 20: 37: 09Z
  5. Я не вижу splice в ваших изменениях, но remove должно быть Array.prototype.remove = function(index) { this.splice(index, 1); };
    2013-08-27 04: 01: 41Z
Старый вопрос, современный ответ. Используя деструктуризацию объекта, 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);
    
147
2016-12-01 20: 51: 19Z
  1. Возможно, потому что цель состоит в том, чтобы удалить свойство из объекта, а не создать новое без свойства ... хотя ваше решение мое любимое, так как я предпочитаю неизменный путь.
    2016-12-01 17: 14: 04Z
  2. В вопросе говорилось, что "в итоге мы получим new myObject".
    2016-12-01 20: 45: 31Z
  3. Добавление Underscore для удаления свойства засоряет ваш проект :) Вместо того, чтобы сделать его доступным как regex, вы также можете назначить его любой другой переменной, например, _, что используется в таких языках, как Go, чтобы отменить результат: const { regex: _, ...newObject } = myObject;.
    2017-06-30 07: 30: 00Z
  4. На самом деле это приятный однострочный текст для нового назначения объекта без нежелательного реквизита, который уже поддерживается с Node.js 8. * /9. * с --harmony: node.green/…
    2017-07-01 18: 51: 14Z
  5. С объектами freeze() 'd и seal()' d вы не можете просто delete свойство. Так что это отличная альтернатива. Хотя в большинстве случаев, вероятно, в любом случае не имеет смысла удалять свойство из замороженного /запечатанного объекта, учитывая, что весь смысл в том, чтобы дать определенные гарантии относительно ваших структур данных, которые этот шаблон будет подрывать. Для тех случаев, когда вам необходимо неразрушающим образом дублировать объект, но без некоторых его свойств, это идеально
    2018-08-03 05: 45: 22Z

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

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

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

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

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

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

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

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

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

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

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

    
88
2018-02-03 19: 51: 40Z
  1. Имейте в виду, что если ключи вашего объекта являются числами, вам может понадобиться _.omit(collection, key.toString())
    2014-12-09 01: 32: 19Z
  2. Хммммм .... Подчеркивание в ~ 100 раз медленнее, чем в delete obj[prop], что в ~ 100 раз медленнее, чем в obj[prop] = undefined.
    2018-04-14 23: 00: 57Z

Синтаксис распространения (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;
    
62
2019-04-23 18: 55: 53Z
  1. Я думаю, что синтаксис распространения /отдыха для литералов объекта был включен только в ES2018 (ES9), а не в ES6, даже если несколько движков JS уже реализовали его.
    2018-12-02 20: 52: 15Z
  2. @ trincot Впервые он был представлен в 2014 году ( github.com/tc39/proposal-object-rest-spread ) и это функция ES6 (ECMAScript 2015, также известная как ECMAScript 6-е издание). Однако даже если я ошибаюсь, я не думаю, что это имеет значение для контекста ответа.
    2018-12-04 21: 56: 09Z
  3. Ссылка относится к ES6, где действительно был введен синтаксис распространения для массивов, но затем он продолжает предлагать нечто подобное для литералов объектов. Эта вторая часть была включена только в ES9, если я не ошибаюсь.
    2018-12-05 07: 03: 19Z

Термин, который вы использовали в заголовке вопроса 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, что означает, что ваш оператор удаления не был выполнен так, как вы ожидали. Но если вы ранее не создавали эту переменную и в качестве последней существующей ссылки у вас было только myOtherObject["regex"], вы могли бы сделать это, просто удалив ее следующим образом:

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

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

Update: Благодаря @AgentME:

  

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

Для получения дополнительной информации о Object.seal: Object .Для неиспользованных отверстий () р>     

45
2015-06-02 22: 18: 26Z
  1. Вы ошибаетесь - в JavaScript по ссылке передаются только объекты, поэтому, если значение myJSONObject.regex является строкой и вы назначаете его какому-либо другому объекту, другому объекту имеет копию этого значения.
    2016-01-10 16: 58: 19Z
  2. Вы правы, и это цитата: «быть осторожным с другими ссылками на тот же объект».
    2016-01-10 17: 34: 48Z

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
2016-01-25 17: 22: 10Z
  1. @ Gothdo имеет больше преимуществ, особенно когда вам нужно сделать что-то функциональное. Например. Вы можете назначить функцию переменной, передать в качестве аргумента или использовать функции apply, call, bind ...
    2016-01-10 16: 47: 18Z

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

 
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
2016-11-23 09: 17: 42Z
  1. Я думаю, вам всегда следует использовать splice в массиве вместо delete.
    2016-09-22 15: 30: 26Z
  2. @ JoelTrauger: Это то, что я говорю; -)
    2016-11-23 09: 19: 15Z
  3. Да. Мой комментарий заключается в том, что delete даже не должно быть вещью. Это splice - это то, что искал ОП.
    2016-11-23 21: 59: 56Z
  4. @ JoelTrauger: Как я пытался объяснить, delete следует использовать для свойств объекта и splice для элементов массива.
    2016-11-24 10: 01: 08Z
  5. Соединение выполняется очень медленно. Хотя он должен использоваться вместо delete в массивах, было бы разумно вообще не создавать код, сосредоточенный вокруг него.
    2018-04-14 23: 05: 43Z

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

Живой пример для показа:

 
var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.
    
27
2016-02-11 20: 30: 34Z
  1. Возможно, стоит отметить, что хотя использование оператора delete полезно в отношении сборка мусора , это может быть неожиданно медленный , в немалой степени часть по той же причине.
    2015-05-06 17: 51: 33Z

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

 
myObject = _.omit(myObject, 'regex');
    
27
2019-01-21 11: 24: 47Z

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

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

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

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

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

  •   
  • Любое свойство, объявленное с помощью 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 /Справочник /Операторы /удалить

    
22
2019-04-16 23: 22: 12Z

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

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

(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
2017-10-24 09: 58: 51Z

Этот пост очень старый, и я нахожу его очень полезным, поэтому я решил поделиться написанной мной функцией unset, если кто-то еще увидит эту статью и подумает, почему она не так проста, как в функции unset 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
2016-11-22 21: 35: 37Z

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

например р>  

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

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

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

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

    
18
2014-09-15 00: 48: 08Z
  1. delete foo.bar работает, даже если bar не существует, поэтому ваш тест слишком сложный, ИМХО.
    2015-06-01 15: 14: 02Z
  2. @ PhiLho, который зависит от того, где вы используете JavaScript. Я считаю, что в Node.js это приводит к сбою вашего сервера.
    2015-06-02 20: 07: 29Z
  3. delete foo.bar; генерирует исключение только в том случае, если foo ложно или если вы находитесь в строгом режиме, а foo является объектом с неконфигурируемым свойством bar.
    2015-06-02 21: 28: 10Z
  4. Я не помню точную проблему, с которой я столкнулся, но я думаю, что проблема может появиться, когда самого foo не существует, и вы пытаетесь удалить его свойство .
    2015-06-02 22: 20: 12Z
  5. Да, вы должны проверить, существует ли foo, в противном случае foo.bar сгенерирует исключение, но вам не нужно проверять существование для bar перед его удалением. Это слишком большая часть моего комментария. : -)
    2015-06-03 09: 16: 35Z

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

(Оператор деструктурирования + распространения)

 
const myObject = {
    regex: "^http://.*",
    b: 2,
    c: 3
};
const { regex, ...noRegex } = myObject;
console.log(noRegex); // => { b: 2, c: 3 }
    
17
2019-06-06 13: 25: 13Z
  1. Я не думаю, что это особенность ES6, но она была включена только в ES9.
    2018-12-02 20: 53: 29Z
  2. да, здесь я попытался использовать ES6 в простых шагах ...
    2018-12-05 05: 54: 00Z
  3. Таким образом, на самом деле вы используете не ES6, как вы пишете, а ES9 ...; -)
    2018-12-05 07: 07: 42Z
  4. Это не удаляет свойство из объекта, а создает новый объект без этого свойства.
    2019-06-21 08: 18: 59Z

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

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

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

    
14
2016-11-28 15: 14: 52Z

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

р>

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

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

console.log(myObject);
    
13
2016-11-22 22: 12: 14Z
  1. Также JSON.parse(JSON.stringify({ ...myObject, regex: undefined }))
    2016-09-25 23: 15: 33Z

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

 
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
2016-06-23 09: 38: 58Z
  1. Эта функция работает как талисман, но зачем нам возвращать true и возвращать false? Моя версия кода: codepen.io/anon/pen/rwbppY . Моя версия потерпит неудачу в любом случае?
    2017-07-17 00: 07: 09Z
  2. @ witty2017 это не даст сбоя. Место, где я использовал функцию, также нужно было проверить, существует ли свойство уже или нет. Если свойство не существует, оно вернет false . Если он найдет свойство и удалит его, он вернет true.
    2017-07-17 05: 52: 42Z

Чтобы клонировать объект без свойства:

Например:

 
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
2019-05-23 09: 02: 03Z

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

Например:

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

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

 
delete obj.key1

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

 
delete obj[key1]

Ссылка: MDN . р>     

7
2016-11-22 22: 11: 24Z

Утверждение Дэна о том, что «удаление» очень медленное, и опубликованный им тест были поставлены под сомнение. Поэтому я сам провел тест в 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
2017-07-26 07: 19: 30Z

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

р>

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

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

console.log(newMyObject);
    
6
2017-10-23 10: 06: 31Z
  1. SyntaxError: Unexpected token '...'. Expected a property name.?
    2018-04-03 20: 24: 59Z
  2. Попробуйте воспользоваться современным браузером, таким как Firefox, Chromium или Safari. И я ожидаю, что это будет работать и с Edge.
    2018-04-03 20: 45: 04Z
  3. В качестве альтернативы, если ваши клиенты вынуждают вас поддерживать устаревшие браузеры, вы можете рассмотреть возможность использования TypeScript, который переводит ваш код в унаследованный синтаксис (+ дает вам преимущество статического типа безопасности).
    2018-04-03 20: 48: 37Z

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
2017-11-10 06: 36: 12Z
  1. 2017-09-19 08: 38: 03Z
    Ля>

р>

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

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

console.log(myObject)
console.log(regex)
console.log(other)
    
6
2018-02-06 04: 28: 57Z

Попробуйте это

 
delete myObject['key'];
    
5
2017-05-26 06: 58: 29Z

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

 
var obj = [];

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

delete(obj.key1);
    
5
2017-05-26 09: 28: 09Z

Использование 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}
    
4
2017-09-14 14: 14: 07Z

Удаление свойства в 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, когда требуется немутативный подход и вам не нужно учитывать ключи символов:

 
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, когда требуется немутативный подход и вам не нужно учитывать ключи символов:

 
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
2017-12-14 02: 35: 29Z
источник размещен Вот