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

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声明であるDeleteについて非常に詳細なブログ投稿を書いています。強くお勧めします。

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と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]

詳細

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非破壊的であり、指定されたインデックスfromからstartto を含む新しい配列を返します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 😇
オブジェクトからプロパティを削除するには、いくつかの一般的な方法があります。
それぞれに長所と短所があります（このパフォーマンス比較を確認してください）。

演算子を削除
Readableおよびshortですが、パフォーマンスが最適化されていないため、多数のオブジェクトを操作している場合は最適な選択ではない可能性があります。

delete obj[key];

再割り当て
より2倍以上速くよりも、deleteしかし、プロパティがあり、ありません削除され、反復することができます。

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

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

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

別の選択肢は、Underscore.jsを使用することですライブラリです。

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

リファレンス：link _.pick（object、* keys）

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

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

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

参照：リンク _.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"];

ここでのもう1つの重要な点は、同じオブジェクトへの他の参照に注意することです。たとえば、次のような変数を作成するとします。

var regex = myJSONObject["regex"];

または、次のような別のオブジェクトへの新しいポインタとして追加します。

var myOtherObject = {};
myOtherObject["regex"] = myJSONObject["regex"];

次に、それをオブジェクトから削除してもmyJSONObject、その特定のオブジェクトはメモリから削除されません。これは、regex変数とmyOtherObject["regex"]その値が残っているためです。では、どうすればオブジェクトをメモリから確実に削除できるでしょうか。

答えはするだろう、あなたのコードを持っているすべての参照を削除するには、その非常にオブジェクトを指摘しても使用しないでvar、そのオブジェクトへの新しい参照を作成するステートメントを。varステートメントに関するこの最後の点は、私たちが通常直面する最も重要な問題の1つです。varすると作成されたオブジェクトが削除されないため、。

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

delete regex; //False

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

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

言い換えると、JavaScriptオブジェクトは、そのオブジェクトを指す参照がコードに残っていない状態になるとすぐに強制終了されます。

更新： @AgentMEに感謝：

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

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

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関数（およびdelete演算子）は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すると、インデックス作成が台無しになります。

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

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

ES6の使用：

（破壊+スプレッド演算子）

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

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

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

delete演算子を行うには、が最適です。

表示するライブの例：

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

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

例えば：

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

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

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

削除演算子は、オブジェクトから特定のプロパティを削除します。削除に成功するとtrueを返し、それ以外の場合はfalseを返します。ただし、次のシナリオを検討することが重要です。

• 削除しようとしているプロパティが存在しない場合、削除は効果がなく、trueを返します

• オブジェクトのプロトタイプチェーンに同じ名前のプロパティが存在する場合、削除後、オブジェクトはプロトタイプチェーンのプロパティを使用します（つまり、削除は自分のプロパティにのみ影響します）。

• varを使用して宣言されたプロパティは、グローバルスコープまたは関数のスコープから削除できません。

• そのため、deleteは、グローバルスコープ内の関数を削除できません（これが関数定義からのものか、関数（式）からのものか）。

• オブジェクトの一部である関数（
  グローバルスコープを除く）は、deleteを使用して削除できます。

• letまたはconstで宣言されたプロパティは、それらが定義されたスコープから削除できません。構成できないプロパティは削除できません。これには、Math、Array、Objectなどの組み込みオブジェクトのプロパティと、Object.defineProperty（）などのメソッドで構成できないものとして作成されたプロパティが含まれます。

次のスニペットは、別の簡単な例を示しています。

var Employee = {
      age: 28,
      name: 'Alireza',
      designation: 'developer'
    }
    
    console.log(delete Employee.name);   // returns true
    console.log(delete Employee.age);    // returns true
    
    // When trying to delete a property that does 
    // not exist, true is returned 
    console.log(delete Employee.salary); // returns true

その他の例の詳細と例については、以下のリンクにアクセスしてください。

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

を使用した別のソリューション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);

この投稿は非常に古く、とても役に立ったので、誰かがこの投稿を見て、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"}

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

例えば

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

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

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

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

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

deleteキーワードを使用して、オブジェクトの任意のプロパティを削除できます。

例えば：

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

プロパティを削除するには、たとえばkey1、次のdeleteようなキーワードを使用します。

delete obj.key1

または、配列のような表記を使用することもできます。

delete obj[key1]

参照：MDN。

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

「削除」は非常に遅いというダンの主張と、彼が投稿したベンチマークは疑われた。そのため、私は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

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

"regex"元のオブジェクトはプログラムの他の部分から常に参照される可能性があるため、プロパティなしで新しいオブジェクトを作成することを検討してください。したがって、それを操作することは避けてください。

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

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

console.log(newMyObject);

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モードの設定不可能なプロパティで使用すると、キャッチされない例外が発生する可能性もあります。

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

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

ES6の構造解除をREST演算子で使用できます。

プロパティは、残りの演算子と組み合わせて破壊を使用して削除できます。あなたの例では、正規表現が分解され（無視され）、残りのプロパティが残りとして返されます。

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

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

または、このようなプロパティを動的に除外できます。

const myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};
const removeProperty = prop => ({ [prop]: _, ...rest }) => rest

const removeRegex = removeProperty('regex') //=> {  "ircEvent": "PRIVMSG","method":"newURI" }
const removeMethod = removeProperty('method') //=> {  "ircEvent": "PRIVMSG", "regex":"^http://.*" }

以下を使用して、JavaScriptオブジェクトから任意のプロパティを削除できます。

1. object.propertyを削除する
2. オブジェクトを削除する['プロパティ']

例：

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

console.log(myObject);

delete myObject.regex;
console.log('=================');
console.log(myObject);
delete myObject['method'];
console.log('=================');
console.log(myObject);

これを試して

delete myObject['key'];