次のようにオブジェクトを作成するとします。

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、彼らのブログ、Understandingdeleteのステートメントについて信じられないほど詳細なブログ投稿を書いています。強くお勧めします。

JavaScriptのオブジェクトは、キーと値の間のマップと考えることができます。deleteオペレータは、より一般的にオブジェクトのプロパティを1つずつとしても知られているこれらのキーを削除するために使用されます。

var obj = {
  myProperty: 1    
}
console.log(obj.hasOwnProperty('myProperty')) // true
delete obj.myProperty
console.log(obj.hasOwnProperty('myProperty')) // false

delete演算子はメモリを直接解放しません。また、プロパティ自体がオブジェクトから削除されるという点で、プロパティの値nullまたはundefinedプロパティへの値の割り当てとは異なります。場合ことを注意値、それに対するすべての参照を持っているまで削除財産のが参照型（オブジェクト）、およびプログラムの別の部分だった今でも、そのオブジェクトへの参照を保持しているが、そのオブジェクトは、もちろん、ないゴミが収集されます消えた。

delete 記述子が構成可能としてマークしているプロパティでのみ機能します。

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

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

これはFirefoxとInternetExplorerで機能し、他のすべてでも機能すると思います。

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]

詳細

deleteJavaScriptでは、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（[begin [、end]]）

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]

Array＃pop

Array#pop配列から最後の要素を削除し、その要素を返します。この操作により、配列の長さが変更されます。

古い質問、現代の答え。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);

スプレッド構文（ES6）

それを必要とする人に...

このスレッドで@Koenの回答を完了するには、spread構文を使用して動的変数を削除する場合、次のように実行できます。

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）の値を持つ新しい変数になります。

EXTENDED ANSWERは😇
オブジェクトからプロパティを削除するには、いくつかの一般的な方法があります。
それぞれに独自の長所と短所があります（このパフォーマンス比較を確認してください）：

Delete Operator
読み取り可能で短いですが、パフォーマンスが最適化されていないため、多数のオブジェクトを操作している場合は、最適な選択ではない可能性があります。

delete obj[key];

再割り当て
は2倍以上高速ですdeleteが、プロパティは削除されず、繰り返すことができます。

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

Spread演算子
このES6演算子を使用すると、既存のオブジェクトを変更せずに、プロパティを除く新しいオブジェクトを返すことができます。欠点は、上記の中でパフォーマンスが低下することであり、一度に多くのプロパティを削除する必要がある場合に使用することはお勧めしません。

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

もう1つの方法は、Underscore.jsライブラリを使用することです。

_.pick()と_.omit()両方がオブジェクトのコピーを返し、元のオブジェクトを直接変更しないことに注意してください。結果を元のオブジェクトに割り当てると、うまくいくはずです（図には示されていません）。

参照：link _.pick（object、* keys）

ホワイトリストに登録されたキー（または有効なキーの配列）の値のみを持つようにフィルタリングされた、オブジェクトのコピーを返します。

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

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

参照：link _.omit（object、* keys）

ブラックリストに登録されたキー（またはキーの配列）を省略するようにフィルタリングされた、オブジェクトのコピーを返します。

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

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

配列の場合、_.filter()および_.reject()同様の方法で使用できます。

質問のタイトルRemove a property from a JavaScript objectで使用した用語は、いくつかの異なる方法で解釈できます。1つはメモリ全体でそれを削除し、オブジェクトキーのリストを削除するか、もう1つはオブジェクトから削除することです。他のいくつかの回答で言及されているように、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すると作成されたオブジェクトが削除されなくなるため、通常直面する最も重要な問題の1つです。

つまり、この場合regex、varステートメントを介して変数を作成したため、そのオブジェクトを削除することはできません。

delete regex; //False

結果はになりますfalse。これは、削除ステートメントが期待どおりに実行されなかったことを意味します。ただし、以前にその変数を作成したことがなくmyOtherObject["regex"]、最後の既存の参照としてしか作成していない場合は、次のように削除するだけでこれを実行できます。

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

つまり、JavaScriptオブジェクトは、そのオブジェクトを指す参照がコードに残っていない場合、すぐに強制終了されます。

更新： @AgentMEに感謝します：

プロパティを削除する前にnullに設定しても、何も実行されません（オブジェクトがObject.sealによってシールされていて、削除が失敗した場合を除きます。特に試してみない限り、通常はそうではありません）。

詳細情報を取得するにはObject.seal：Object.seal（）

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

次のようなオブジェクトがあるとします。

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'];

同様に、students配列全体を削除するには、delete Hogwarts.students;またはを呼び出しdelete Hogwarts['students'];ます。

配列インデックスの削除

ここで、1人のスタッフまたは学生を削除する場合、両方のプロパティ自体が配列であるため、手順が少し異なります。

スタッフのインデックスがわかっている場合は、次のようにするだけです。

Hogwarts.staff.splice(3, 1);

インデックスがわからない場合は、インデックス検索も行う必要があります。

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

注意

技術的にはdelete配列に使用できますが、それを使用すると、たとえばHogwarts.staff.length後で呼び出すときに誤った結果が得られます。つまり、delete要素は削除されますが、lengthプロパティの値は更新されません。を使用deleteすると、インデックス作成も混乱します。

したがって、オブジェクトから値を削除するときは、常に最初にオブジェクトプロパティを扱っているのか、配列値を扱っているのかを検討し、それに基づいて適切な戦略を選択してください。

これを試してみたい場合は、このフィドルを出発点として使用できます。

プロパティなしでオブジェクトを複製するには：

例えば：

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

そして、を削除する必要がありaます。

1. 明示的な小道具キー：

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

1. 可変プロップキー：

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

1. クールな矢印機能😎：

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

    object = removePropery('a', object);

1. 以下のための複数のプロパティ

    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 }

私は個人的にUnderscore.jsまたはLodashをオブジェクトと配列の操作に使用しています。

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

MDNの説明に従って、deleteメソッドを使用するのが最善の方法です。削除演算子は、オブジェクトからプロパティを削除します。だからあなたは簡単に書くことができます：

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

削除演算子は、指定されたプロパティをオブジェクトから削除します。削除が成功するとtrueが返され、そうでない場合はfalseが返されます。ただし、次のシナリオを考慮することが重要です。

• 削除しようとしているプロパティが存在しない場合、deleteは効果がなく、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

を使用した別の解決策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);

ここには良い答えがたくさんありますが、JavaScriptで削除を使用してプロパティを削除するときは、エラーを防ぐためにそのプロパティが存在するかどうかを最初に確認するのが賢明です。

例えば

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

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

JavaScriptの動的な性質により、プロパティが存在するかどうかがわからない場合がよくあります。&&の前にobjが存在するかどうかを確認すると、未定義のオブジェクトでhasOwnProperty（）関数を呼び出したためにエラーがスローされないことも確認できます。

これが特定のユースケースに追加されなかった場合は申し訳ありませんが、これはオブジェクトとそのプロパティを管理するときに適応するための優れた設計であると思います。

この投稿は非常に古く、非常に役立つと思います。他の誰かがこの投稿を見て、PHPのunset関数ほど単純ではない理由を考える場合に備えて、私が書いたunset関数を共有することにしました。

この新しいunset関数を作成する理由は、このhash_map内の他のすべての変数のインデックスを保持するためです。次の例を見て、hash_mapから値を削除した後、「test2」のインデックスがどのように変更されなかったかを確認してください。

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

ramda＃dissocを使用すると、属性のない新しいオブジェクトを取得できますregex。

const newObject = R.dissoc('regex', myObject);
// newObject !== 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);

オブジェクトに深くネストされたプロパティを削除する場合は、2番目の引数としてプロパティへのパスを指定して次の再帰関数を使用できます。

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

「削除」というダンの主張は非常に遅く、彼が投稿したベンチマークは疑わしいものでした。そこで、Chrome59で自分でテストを実行しました。「削除」は約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

他の操作による影響を最小限に抑えるために、1つのループサイクルで意図的に複数の「削除」操作を実行したことに注意してください。

JavaScriptでのプロパティの削除

このページにはさまざまなオプションが表示されますが、これはほとんどのオプションが間違っているため、または回答が重複しているためではなく、適切な手法が現在の状況やタスクの目標によって異なるためです。チームは達成しようとしています。質問に明確に答えるには、次のことを知っておく必要があります。

1. ターゲットにしているECMAScriptのバージョン
2. プロパティを削除するオブジェクトタイプの範囲と省略できるプロパティ名のタイプ（文字列のみ？シンボル？任意のオブジェクトからマップされた弱い参照？これらはすべて、JavaScriptのプロパティポインタのタイプです。 ）
3. あなたとあなたのチームが使用するプログラミングの精神/パターン。あなたは機能的なアプローチを好み、突然変異はあなたのチームで冗長になっていますか、それとも野生の西の突然変異オブジェクト指向技術を採用していますか？
4. 純粋なJavaScriptでこれを実現しようとしていますか、それともサードパーティのライブラリを使用する意思と能力がありますか？

これらの4つのクエリに回答すると、JavaScriptには基本的に4つのカテゴリの「プロパティの削除」があり、目標を達成するために選択できます。彼らです：

変異オブジェクトプロパティの削除、安全ではありません

このカテゴリは、元の参照を保持/継続して使用し、コードでステートレス関数型の原則を使用していない場合に、オブジェクトリテラルまたはオブジェクトインスタンスを操作するためのものです。このカテゴリの構文の例：

'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で機能します。ただし、これは一部のプログラミング原則に違反し、パフォーマンスに影響を与える変異型です。また、strictモードで構成不可能なプロパティで使用すると、キャッチされない例外が発生する可能性があります。

RESTベースの文字列プロパティの省略

このカテゴリは、非変更アプローチが必要で、シンボルキーを考慮する必要がない場合に、新しい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 :(

ライブラリベースのプロパティの省略

このカテゴリでは、通常、シンボルの説明や1つのステートメントでの複数のプロパティの省略など、機能の柔軟性を高めることができます。

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を使用する

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

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

以下のようなフィルターを使用できます

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)

ネストされたオブジェクトでも発生するように、lodash "unset"を使用しました。これだけで、omitメソッドで予期されるプロパティキーのパスを取得するための小さなロジックを作成する必要があります。

1. プロパティパスを配列として返すメソッド

var a = {"bool":{"must":[{"range":{"price_index.final_price":{"gt":"450","lt":"500"}}},{"bool":{"should":[{"term":{"color_value.keyword":"Black"}}]}}]}};

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

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

<div id="output"> 

</div>

1. 次に、lodash unsetメソッドを使用して、オブジェクトからプロパティを削除します。

var unset = require('lodash.unset');
unset(a,getPathOfKey(a,"price_index.final_price"));

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スプライスを使用して通常の配列の場合と同じように要素を削除するか、配列のようにオブジェクトを単純にフィルタリングして、再構築されたオブジェクトを元の変数に割り当てることもできます。

元のオブジェクトを変更したくない場合。

オブジェクトを変更せずにプロパティを削除する

可変性が懸念される場合は、削除するプロパティを除いて、古いプロパティからすべてのプロパティをコピーすることで、完全に新しいオブジェクトを作成できます。

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