Скажем, я создаю объект следующим образом:
let myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
Каков наилучший способ удалить свойство, regex
чтобы закончить с новым myObject
следующим образом?
let myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI"
};
Нравится:
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
утверждении в своем блоге « Понимание удаления» . Настоятельно рекомендуется.
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 */
var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
delete myObject.regex;
console.log ( myObject.regex); // logs: undefined
Это работает в Firefox и Internet Explorer, и я думаю, что это работает во всех остальных.
delete
Оператор используется для удаления свойств из объектов.
const obj = { foo: "bar" }
delete obj.foo
obj.hasOwnProperty("foo") // false
Обратите внимание, что для массивов это не то же самое, что удаление элемента . Чтобы удалить элемент из массива, используйте Array#splice
или Array#pop
. Например:
arr // [0, 1, 2, 3, 4]
arr.splice(3,1); // 3
arr // [0, 1, 2, 4]
подробности
delete
в JavaScript функция отличается от функции ключевого слова в C и C ++: он не освобождает память напрямую. Вместо этого его единственной целью является удаление свойств из объектов.
Для массивов удаление свойства, соответствующего индексу, создает разреженный массив (т. Е. Массив с «дырой» в нем). Большинство браузеров представляют эти индексы отсутствующих массивов как «пустые».
var array = [0, 1, 2, 3]
delete array[2] // [0, 1, empty, 3]
Обратите внимание, что delete
не перемещается array[3]
в array[2]
.
Различные встроенные функции в JavaScript по-разному обрабатывают разреженные массивы.
for...in
пропустит пустой индекс полностью.Традиционный
for
цикл возвращаетundefined
значение в индексе.Любой использующий метод
Symbol.iterator
вернётundefined
значение в индексе.forEach
,map
Иreduce
просто пропустить отсутствующий индекс.
Таким образом, delete
оператор не должен использоваться для общего случая удаления элементов из массива. Массивы имеют специальные методы для удаления элементов и перераспределения памяти: Array#splice()
и Array#pop
.
Array # splice (start [, deleteCount [, item1 [, item2 [, ...]]]])
Array#splice
мутирует массив и возвращает все удаленные индексы. deleteCount
элементы удаляются из индекса start
и item1, item2... itemN
вставляются в массив из индекса start
. Если deleteCount
опущен, то элементы из startIndex удаляются до конца массива.
let a = [0,1,2,3,4]
a.splice(2,2) // returns the removed elements [2,3]
// ...and `a` is now [0,1,4]
Существует также же названием, но другой, функция на Array.prototype
: Array#slice
.
Array # slice ([начало [, конец]])
Array#slice
является неразрушающим и возвращает новый массив, содержащий указанные индексы, из start
to end
. Если end
не указан, по умолчанию используется конец массива. Если end
оно положительное, оно указывает нулевой не включающий индекс, на котором стоит остановиться. Если end
оно отрицательное, оно указывает индекс, на котором нужно остановиться, начиная отсчет с конца массива (например, -1 опускает конечный индекс). Если end <= start
, результат - пустой массив.
let a = [0,1,2,3,4]
let slices = [
a.slice(0,2),
a.slice(2,2),
a.slice(2,3),
a.slice(2,5) ]
// a [0,1,2,3,4]
// slices[0] [0 1]- - -
// slices[1] - - - - -
// slices[2] - -[3]- -
// slices[3] - -[2 4 5]
Массив # поп
Array#pop
удаляет последний элемент из массива и возвращает этот элемент. Эта операция изменяет длину массива.
delete
функцию «Сборка мусора» для ее очистки. splice
в ваших remove
Array.prototype.remove = function(index) { this.splice(index, 1); };
Термин, который вы использовали в заголовке вашего вопроса 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 уничтожается, как только в вашем коде не остается ссылки на этот объект.
Обновление: благодаря @AgentME:
Установка свойства в null перед его удалением ничего не делает (если только объект не был запечатан Object.seal и удаление завершилось неудачно. Обычно это не так, если вы не попытались это сделать).
Чтобы получить больше информации о Object.seal
: Object.seal ()
myJSONObject.regex
значение является строкой, и вы присваиваете его другому объекту, у другого объекта есть копия этого значения. Объекты в JavaScript могут рассматриваться как карты между ключами и значениями. delete
Оператор используется , чтобы удалить эти ключи, более широко известные как свойства объекта, по одному за раз.
var obj = {
myProperty: 1
}
console.log(obj.hasOwnProperty('myProperty')) // true
delete obj.myProperty
console.log(obj.hasOwnProperty('myProperty')) // false
delete
Оператор непосредственно не свободной памяти, и оно отличается от простого присвоения значения null
или undefined
к свойству, в том , что свойство само по себе удаляется из объекта. Обратите внимание, что если значением удаленного свойства был ссылочный тип (объект), а другая часть вашей программы по-прежнему содержит ссылку на этот объект, то этот объект, разумеется, не будет собирать мусор, пока все ссылки на него не будут иметь исчез.
delete
будет работать только со свойствами, дескриптор которых помечает их как настраиваемые.
Другой альтернативой является использование библиотеки 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()
может быть использован аналогичным образом.
_.omit(collection, key.toString())
delete obj[prop]
в ~ 100 раз медленнее, чем obj[prop] = undefined
. Здесь есть много хороших ответов, но я просто хочу сказать, что при использовании delete для удаления свойства в JavaScript часто целесообразно сначала проверить, существует ли это свойство, чтобы избежать ошибок.
Например
var obj = {"property":"value", "property2":"value"};
if (obj && obj.hasOwnProperty("property2")) {
delete obj.property2;
} else {
//error handling
}
Из-за динамической природы JavaScript часто бывают случаи, когда вы просто не знаете, существует свойство или нет. Проверка существования obj перед тем, как && также гарантирует, что вы не выдадите ошибку из-за вызова функции hasOwnProperty () для неопределенного объекта.
Извините, если это не добавилось к вашему конкретному варианту использования, но я считаю, что это хороший дизайн для адаптации при управлении объектами и их свойствами.
delete foo.bar;
Исключение выдается только в том случае, если foo ложно или если вы находитесь в строгом режиме, а foo является объектом с неконфигурируемым свойством bar. Этот пост очень старый, и я нахожу его очень полезным, поэтому я решил поделиться функцией 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"}
Оператор удаления - лучший способ сделать это.
Живой пример, чтобы показать:
var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.
delete
оператора полезно для сбора мусора , оно может быть неожиданно медленным , в немалой степени по той же причине. 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
apply
, call
, bind
функции ...Я лично использую Underscore.js или Lodash для манипулирования объектами и массивами:
myObject = _.omit(myObject, 'regex');
Предположим, у вас есть объект, который выглядит следующим образом:
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
также может испортить вашу индексацию.
Таким образом, при удалении значений из объекта всегда сначала учитывайте, имеете ли вы дело со свойствами объекта или со значениями массива, и выбирайте соответствующую стратегию на основе этого.
Если вы хотите поэкспериментировать с этим, вы можете использовать эту скрипку в качестве отправной точки.
splice
массив вместо delete
. delete
даже не должно быть вещью. Это splice
то, что искал ОП. delete
должен использоваться для свойств объекта и splice
для элементов массива. delete
массивов, было бы разумно вообще не создавать код, сконцентрированный вокруг него. Вы можете просто удалить любое свойство объекта, используя delete
ключевое слово.
Например:
var obj = {key1:"val1",key2:"val2",key3:"val3"}
Например, чтобы удалить любое свойство, key1
используйте delete
ключевое слово, например:
delete obj.key1
Или вы также можете использовать массивную запись:
delete obj[key1]
Ссылка: MDN .
Если вы хотите удалить свойство, глубоко вложенное в объект, то вы можете использовать следующую рекурсивную функцию с путем к свойству в качестве второго аргумента:
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: {}}}
Попробуйте следующий метод. Присвойте Object
значение свойства undefined
. Тогда stringify
объект и parse
.
var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
myObject.regex = undefined;
myObject = JSON.parse(JSON.stringify(myObject));
console.log(myObject);
JSON.parse(JSON.stringify({ ...myObject, regex: undefined }))
Старый вопрос, современный ответ. Используя деструктуризацию объектов, функцию 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.
Редактировать:
Чтобы переназначить одну и ту же переменную, используйте let
:
let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);
regex
вы могли бы также назначить его на какой - либо другой переменной, например _
, то , что используется в таких языках , как Go отбрасывать результат: const { regex: _, ...newObject } = myObject;
. const { [key], ...newObject } = myObject;
но это не так, поэтому я не думаю, что это возможно с разрушением. freeze()
'd и seal()
' d вы не можете просто delete
создать свойство. Так что это отличная альтернатива. Хотя в большинстве случаев, вероятно, в любом случае не имеет смысла удалять свойство из замороженного / запечатанного объекта, учитывая, что весь смысл в том, чтобы обеспечить определенные гарантии относительно ваших структур данных, которые этот шаблон будет подрывать. Для тех случаев, когда вам необходимо неразрушающим образом дублировать объект, но без некоторых его свойств, это идеальноИспользуя ramda # disoc, вы получите новый объект без атрибута regex
:
const newObject = R.dissoc('regex', myObject);
// newObject !== myObject
Вы также можете использовать другие функции для достижения того же эффекта - опустить, выбрать, ...
Другое решение, использующее 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);
Использование метода удаления - лучший способ сделать это, согласно описанию MDN, оператор удаления удаляет свойство из объекта. Так что вы можете просто написать:
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
Попробуй это
delete myObject['key'];
Здравствуйте, вы можете попробовать это просто сортировка
var obj = [];
obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};
delete(obj.key1);
Очень просто:
var myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
delete myObject.regex;
Утверждение Дэна о том, что «удаление» очень медленное, и опубликованный им тест были поставлены под сомнение. Итак, я провел тест самостоятельно в 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
Обратите внимание, что я намеренно выполнил более одной операции удаления в одном цикле цикла, чтобы минимизировать эффект, вызванный другими операциями.
Используя 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}
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"];
}
}
);
Я использовал lodash "unset", чтобы это произошло и для вложенного объекта ... только для этого нужно написать небольшую логику, чтобы получить путь к ключу свойства, ожидаемый методом omit.
- Метод, который возвращает путь свойства как массив
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>
- Затем просто с помощью метода lodash unset удалите свойство из объекта.
var unset = require('lodash.unset');
unset(a,getPathOfKey(a,"price_index.final_price"));
Вы можете использовать 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
, или если в строгом режиме оно выдаст ошибку.
Подумайте о создании нового объекта без "regex"
свойства, потому что на исходный объект всегда могут ссылаться другие части вашей программы. Таким образом, вы должны избегать манипулирования им.
const myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
const { regex, ...newMyObject } = myObject;
console.log(newMyObject);
SyntaxError: Unexpected token '...'. Expected a property name.
? Удаление недвижимости в JavaScript
На этой странице представлено много разных опций не потому, что большинство опций неверны, или потому, что ответы дублируются, а потому, что подходящая техника зависит от ситуации, в которой вы находитесь, и целей задач, которые вы и / или вы Команда пытается выполнить. Чтобы ответить на ваш вопрос однозначно, нужно знать:
- Версия ECMAScript, на которую вы ориентируетесь
- Диапазон типов объектов, для которых вы хотите удалить свойства, и тип имен свойств, которые необходимо пропустить (Только строки? Символы? Слабые ссылки, сопоставленные с произвольными объектами? Все это были типы указателей свойств в JavaScript уже много лет )
- Этос / паттерны программирования, которые вы и ваша команда используете. Вы предпочитаете функциональные подходы, и мутация в вашей команде - это словесно, или вы используете методы объектно-ориентированных мутаций на Диком Западе?
- Вы хотите добиться этого в чистом JavaScript или хотите и можете использовать стороннюю библиотеку?
После того, как на эти четыре запроса дан ответ, по сути, в JavaScript есть четыре категории «удаления свойств», чтобы удовлетворить ваши цели. Они есть:
Мутативное удаление свойства объекта, небезопасное
Эта категория предназначена для работы с литералами объекта или экземплярами объекта, когда вы хотите сохранить / продолжить использовать исходную ссылку и не используете функциональные принципы без сохранения состояния в вашем коде. Пример синтаксиса в этой категории:
'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
delete iLikeMutatingStuffDontI[Symbol.for('amICool')] // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
delete iLikeMutatingStuffDontI['amICool'] // throws
Эта категория является самой старой, наиболее простой и широко поддерживаемой категорией удаления имущества. Он поддерживает Symbol
& индексы массивов в дополнение к строкам и работает во всех версиях JavaScript, кроме самого первого выпуска. Однако это мутация, которая нарушает некоторые принципы программирования и влияет на производительность. Это также может привести к неперехваченным исключениям при использовании ненастраиваемых свойств в строгом режиме .
Пропуск свойства покоя на основе строки
Эта категория предназначена для работы с обычными объектами или массивами в более новых разновидностях 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"
const myObject = {
"ircEvent": "PRIVMSG",
"method": "newURI",
"regex": "^http://.*"
};
const { regex, ...other } = myObject;
console.log(myObject)
console.log(regex)
console.log(other)
delete myObject.regex;
.