如何从JavaScript对象中删除属性?

2020/09/13 15:09 · javascript ·  · 0评论

说我创建一个对象,如下所示:

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

删除该属性regex以使其最终成为new 的最佳方法是什么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涉及其博客上声明“ 了解删除”强烈建议。

JavaScript中的对象可以视为键和值之间的映射。delete操作者被用来去除这些键,更通常被称为对象属性,一次一个。

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

delete操作者不直接自由存储器,并且它简单地从分配的值不同nullundefined到的属性,在该属性本身从对象中删除。请注意,如果已删除属性是引用类型(一个对象),而程序的另一部分仍保留对该对象的引用,则在对该对象的所有引用都包含之前,该对象当然不会被垃圾回收。不见了

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

请注意,对于数组,这与删除element不同要从数组中删除元素,请使用Array#spliceArray#pop例如:

arr // [0, 1, 2, 3, 4]
arr.splice(3,1); // 3
arr // [0, 1, 2, 4]

细节

deleteJavaScript中的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索引处的值。

  • forEachmap并且reduce只会跳过缺少的索引。

因此,delete不应运算符用于从数组中删除元素的常见用例。数组具有删除元素和重新分配内存的专用方法:Array#splice()Array#pop

Array#splice(start [,deleteCount [,item1 [,item2 [,...]]]])

Array#splice更改数组,并返回所有删除的索引。deleteCount从index中删除元素start,并item1, item2... itemN从index中将其插入数组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.prototypeArray#slice

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]

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答案,如果您要使用传播语法删除动态变量,可以这样进行:

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

重新分配的

速度比快2倍以上
delete,但是不会删除该属性,并且可以对其进行迭代。

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

Spread运算符

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

参考: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可以用不同的方式解释。一种是将其整个内存和对象键列表删除,另一种只是将其从对象中删除。正如在其他一些答案中提到的那样,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,这意味着您的delete语句未按预期执行。但是,如果您之前没有创建过该变量,而仅将其myOtherObject["regex"]作为最后一个现有引用,则可以通过删除它来完成此操作,例如:

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

换句话说,只要您的代码中没有指向该对象的引用,JavaScript对象就会被杀死。


更新:
感谢@AgentME:

在删除属性之前将属性设置为null不会完成任何操作(除非该对象已被Object.seal密封并且删除失败。除非您特别尝试,否则通常情况并非如此)。

要获取更多信息Object.sealObject.seal()

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函数(以及delete运算符false在尝试删除其任何属性时返回如果property是可配置的true,则即使property不存在,也会返回

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

使用ES6:

(解构+传播运算符)

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

假设您有一个看起来像这样的对象:

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将删除元素,但不会更新lengthproperty 的值使用delete也会使您的索引混乱。

因此,在从对象中删除值时,请始终首先考虑您是在处理对象属性还是在处理数组值,然后基于此选择适当的策略。

如果您想尝试一下,可以使用此小提琴作为起点。

我个人使用Underscore.jsLodash的对象和数组操作:

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 myObject.regex;
// OR
delete myObject['regex'];

delete运算符从对象中删除给定的属性。成功删除后,它将返回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/zh-CN/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);

这篇文章很老,我发现它很有帮助,所以我决定分享我写的unset函数,以防其他人看到这篇文章,并思考为什么它不像PHP 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"}

这里有很多很好的答案,但我只是想提醒一下,在使用delete删除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);

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

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

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

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

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

console.log(newMyObject);

我们可以使用以下方法从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关键字删除对象的任何属性

例如:

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

要删除任何属性,请说key1,使用如下delete关键字:

delete obj.key1

或者,您也可以使用类似数组的符号:

delete obj[key1]

参考:MDN

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

请注意,我有意在一个循环中执行了多个“删除”操作,以最大程度地减少其他操作引起的影响。

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

var obj = [];

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

delete(obj.key1);

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

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

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"
const myObject = {
        "ircEvent": "PRIVMSG",
        "method": "newURI",
        "regex": "^http://.*"
    };

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

console.log(myObject)
console.log(regex)
console.log(other)
本文地址:http://javascript.askforanswer.com/ruhecongjavascriptduixiangzhongshanchushuxing.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!