您好，您可以尝试这种简单的排序

var obj = [];

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

delete(obj.key1);

考虑创建不带"regex"属性的新对象，因为原始对象始终可以被程序的其他部分引用。因此，您应该避免对其进行操作。

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

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

console.log(newMyObject);

丹的断言“删除”非常缓慢，他发布的基准受到质疑。因此，我自己在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关键字。

例如：

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

请尝试以下方法。将Object属性值分配给undefined。然后stringify是对象和parse。

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

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

console.log(myObject);

这里有很多很好的答案，但我只是想提醒一下，在使用delete删除JavaScript中的属性时，通常最好先检查该属性是否存在以防止错误。

例如

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

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

由于JavaScript的动态特性，通常在某些情况下您根本不知道该属性是否存在。检查obj在&&之前是否存在，还可以确保您不会由于未定义对象上调用hasOwnProperty（）函数而引发错误。

抱歉，这没有添加到您的特定用例中，但是我相信这是在管理对象及其属性时可以适应的一个很好的设计。

如果要删除深深嵌套在对象中的属性，则可以使用以下递归函数，并将该属性的路径作为第二个参数：

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

使用ES6：

（解构+传播运算符）

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

另一种选择是使用Underscore.js库。

请注意，_.pick()并_.omit()都返回对象的副本，但不直接修改原始对象。将结果分配给原始对象应该可以解决这个问题（未显示）。

参考：链接 _.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()可以以类似的方式使用。

旧问题，现代答案。使用对象分解（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);

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

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

这适用于Firefox和Internet Explorer，我认为它适用于所有其他产品。