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

Мы можем удалить с помощью

1. с помощью удаления object.property
2. с помощью удаления объекта['свойство']
3. используя остальные, удалить несколько свойств

let myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*",
  "regex1": "^http://.*",
  "regex2": "^http://.*",
  "regex3": "^http://.*",
  "regex4": "^http://.*"
};

delete myObject.regex; // using delete object.property

// Or 

delete myObject['regex1']; // using delete object['property']

const { regex2, regex3, regex4, ...newMyObject } = myObject;

console.log(newMyObject);

Есть несколько вариантов:

1. Удалить с помощью метода доступа к точечному свойству

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

delete myObject.regex;
console.log(myObject);

2. Удалить свойство с помощью квадратных скобок

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

delete myObject['regex'];
console.log(myObject);
// or
const name = 'ircEvent';
delete myObject[name];
console.log(myObject);

3. Альтернативный вариант, но в неизменном виде без изменения исходного объекта, использует деструктурирование объекта и синтаксис остатка.

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

const { regex, ...myObjectRest} = myObject;
console.log(myObjectRest); 

Давайте будем проще, по существу:

Просто установите это конкретное свойство/поле равным = undefined

var myObject = {
    'i': "How are you?",
    'am': "Dear",
    'fine': "Hello"
};

myObject.am = undefined;

console.log(myObject);

> {i: "How are you?", am: undefined, fine: "Hello"}

Два способа удалить объект

1. с использованием для ... в

    function deleteUser(key) {
   
        const newUsers = {};
        for (const uid in users) {
            if (uid !== key) {
                newUsers[uid] = users[uid];
            }
   
        return newUsers
    }
   

или

delete users[key]

Вот способ ES6 легко удалить запись:

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

const removeItem = 'regex';

const { [removeItem]: remove, ...rest } = myObject;

console.log(remove); // "^http://.*"
console.log(rest); // Object { ircEvent: "PRIVMSG", method: "newURI" }

Если вы не хотите изменять исходный объект.

Удалить свойство без изменения объекта

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

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

let prop = 'regex';
const updatedObject = Object.keys(myObject).reduce((object, key) => {
  if (key !== prop) {
    object[key] = myObject[key]
  }
  return object
}, {})

console.log(updatedObject);

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


obj = Object.fromEntries(
    Object.entries(myObject).filter(function (m){
        return m[0] != "regex"/*or whatever key to delete*/
    }
))

console.log(obj)

Вы также можете просто обрабатывать объект как массив a2d, используя Object.entries, и использовать splice для удаления элемента, как в обычном массиве, или просто фильтровать объект, как в массиве, и назначать восстановленный объект обратно к исходной переменной

Вы можете использовать фильтр, как показано ниже

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

// Way 1

let filter1 = {}
  Object.keys({...myObject}).filter(d => {
  if(d !== 'regex'){
    filter1[d] = myObject[d];
  }
})

console.log(filter1)

// Way 2

let filter2 = Object.fromEntries(Object.entries({...myObject}).filter(d =>
d[0] !== 'regex'
))

console.log(filter2)

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

Например:

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

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

1. С явным ключом пропуска :

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

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

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

3. Классная стрелочная функция ????:

    const removeProperty = (propKey, { [propKey]: propValue, ...rest }) => rest;
   
    object = removeProperty('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 }

Синтаксис расширения (ES6)

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

const key = 'a';

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

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

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

Расширенный ответ ????

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

Удалить оператор

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

delete obj[key];

Переназначение

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

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

Оператор распространения

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

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

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

Удаление свойства в 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"

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

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

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

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}

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

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

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

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

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

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

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

• Любое свойство, объявленное с помощью 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

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

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

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

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

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

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

Старый вопрос, современный ответ. Используя деструктуризацию объекта, функцию 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);

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

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

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

console.log(myObject);

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

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: {}}}

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

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

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

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

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

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

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

Reflect.deleteProperty(myJSONObject, 'regex');

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

delete myJSONObject['regex'];

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

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

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

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

Например,

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

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

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

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

Другой альтернативой является использование библиотеки 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() можно использовать аналогичным образом.

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

Термин, который вы использовали в заголовке вопроса, Удалить свойство из объекта JavaScript , можно интерпретировать по-разному. Один - удалить его для всей памяти и список ключей объекта, другой - просто удалить его из вашего объекта. Как уже упоминалось в некоторых других ответах, ключевое слово 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()

Оператор 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.

Соединение массива # (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 является неразрушающим и возвращает новый массив, содержащий указанные индексы от start до 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]

Массив # pop

Array#pop удаляет последний элемент из массива и возвращает этот элемент. Эта операция изменяет длину массива.

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

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

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