将javascript对象与“未定义”属性进行比较？

lodash/Underline.isEqualo1，o2或assert.deepEqualo1，o2应该如何处理具有未定义值的对象？我想要一个在这种情况下返回true的deepEquals：

 var left = {a: true, b: undefined};
 var right = {a: true};
 assert(_.isEqual(left, right))   // returns false

或者，是否有一种方法可以测试属性b是否定义为未定义或只是未定义

 typeof left.b //  "undefined"
 typeof right.b // "undefined

 left.b === undefined  // true
 right.b === undefined // true

现在我使用这个是为了权宜之计，但我怀疑它会产生误报：

var isEqual = function(o1, o2) { return JSON.stringify(o1) === JSON.stringify(o2)}

左不等于右的原因是因为b是左边的一个属性，即使它是未定义的

要检查对象上是否存在该属性，即使该属性未定义（如左图示例所示），请使用in运算符：

"b" in left; // true
"b" in right; // false

操作员中的Javascript：

用于检查属性是否存在且未定义的快速函数：

function propertyExistsAndIsUndefined(object, property) {
    return property in object && typeof object[property] === "undefined";
}

左不等于右的原因是因为b是左边的一个属性，即使它是未定义的

要检查对象上是否存在该属性，即使该属性未定义（如左图示例所示），请使用in运算符：

"b" in left; // true
"b" in right; // false

操作员中的Javascript：

用于检查属性是否存在且未定义的快速函数：

function propertyExistsAndIsUndefined(object, property) {
    return property in object && typeof object[property] === "undefined";
}

或者，是否有一种方法可以测试属性b是否定义为未定义或只是未定义

 typeof left.b //  "undefined"
 typeof right.b // "undefined

 left.b === undefined  // true
 right.b === undefined // true

是的，有很多方法可以区分这些情况

"b" in left; // true
"b" in right; // false

left.hasOwnProperty("b"); // true
right.hasOwnProperty("b"); // false

left.propertyIsEnumerable('b'); // true
right.propertyIsEnumerable('b'); // false

Object.keys(left).includes("b"); // true
Object.keys(right).includes("b"); // false

Object.getOwnPropertyNames(left).includes("b"); // true
Object.getOwnPropertyNames(right).includes("b"); // false

Reflect.ownKeys(left).includes("b"); // true
Reflect.ownKeys(right).includes("b"); // false

!!Object.getOwnPropertyDescriptor(left, 'b'); // true
!!Object.getOwnPropertyDescriptor(right, 'b'); // false

!!Reflect.getOwnPropertyDescriptor(left, 'b'); // true
!!Reflect.getOwnPropertyDescriptor(right, 'b'); // false

!!(o => {for(var p in o) if(p==='b') return 1; return 0;})(left); // true
!!(o => {for(var p in o) if(p==='b') return 1; return 0;})(right); // false

看看带注释的源代码，我认为这就足够了：

_.myEqual = function(a,b) {
  var keys = _.keys;
  _.keys = function(obj) { /* Hijack _.keys to filter out undefined properties */
    return _.filter(keys(obj), function(key){ return obj[key] !== void 0; });
  };
  var ret = _.isEqual(a,b); /* Call usual comparator, will use modified _.keys */
  _.keys = keys; /* Restore usual _.keys */
  return ret;
}

_.myEqual=functiona，b{ var-keys=u.keys； _.keys=functionobj{ 返回u.filterkeysobj，key=>obj[key]！==void 0； }; var ret=u.isEquala，b； _.钥匙=钥匙； 返回ret； } console.log..myEqual{a:true，b:undefined}，{a:true}；//符合事实的 console.log..myEqual{a:true，b:true}，{a:true}；//错误的 或者，是否有一种方法可以测试属性b是否定义为未定义或只是未定义

 typeof left.b //  "undefined"
 typeof right.b // "undefined

 left.b === undefined  // true
 right.b === undefined // true

是的，有很多方法可以区分这些情况

"b" in left; // true
"b" in right; // false

left.hasOwnProperty("b"); // true
right.hasOwnProperty("b"); // false

left.propertyIsEnumerable('b'); // true
right.propertyIsEnumerable('b'); // false

Object.keys(left).includes("b"); // true
Object.keys(right).includes("b"); // false

Object.getOwnPropertyNames(left).includes("b"); // true
Object.getOwnPropertyNames(right).includes("b"); // false

Reflect.ownKeys(left).includes("b"); // true
Reflect.ownKeys(right).includes("b"); // false

!!Object.getOwnPropertyDescriptor(left, 'b'); // true
!!Object.getOwnPropertyDescriptor(right, 'b'); // false

!!Reflect.getOwnPropertyDescriptor(left, 'b'); // true
!!Reflect.getOwnPropertyDescriptor(right, 'b'); // false

!!(o => {for(var p in o) if(p==='b') return 1; return 0;})(left); // true
!!(o => {for(var p in o) if(p==='b') return 1; return 0;})(right); // false

看看带注释的源代码，我认为这就足够了：

_.myEqual = function(a,b) {
  var keys = _.keys;
  _.keys = function(obj) { /* Hijack _.keys to filter out undefined properties */
    return _.filter(keys(obj), function(key){ return obj[key] !== void 0; });
  };
  var ret = _.isEqual(a,b); /* Call usual comparator, will use modified _.keys */
  _.keys = keys; /* Restore usual _.keys */
  return ret;
}

_.myEqual=functiona，b{ var-keys=u.keys； _.keys=functionobj{ 返回u.filterkeysobj，key=>obj[key]！==void 0； }; var ret=u.isEquala，b； _.钥匙=钥匙； 返回ret； } console.log..myEqual{a:true，b:undefined}，{a:true}；//符合事实的 console.log..myEqual{a:true，b:true}，{a:true}；//错误的

---

这将去掉未定义的属性，并保留assert.deepEqual和uqual-like对属性顺序不敏感的其他可取属性：

assert.jsonEqual=functiona，b{ 返回deepEqualJSON.parseJSON.stringifya、JSON.parseJSON.stringifyb }

---

这将去掉未定义的属性，并保留assert.deepEqual和u.isEqual-like对属性顺序不敏感的其他可取属性：

assert.jsonEqual=functiona，b{ 返回deepEqualJSON.parseJSON.stringifya、JSON.parseJSON.stringifyb }

---

为了完整性，您可以添加PropertyEnumerable，为了完整性，您可以添加PropertyEnumerable，为什么不在object中添加property&&object[property]===未定义？未定义可能会被其他人覆盖。由于undefined只是值未定义的全局对象的一个属性，您可以编写undefined=true，现在object[property]==undefined将返回false。现代浏览器不允许未定义为不可写，但仍然允许。undefined也不是保留字，所以我想您也可以创建一个名为undefined的局部变量。typeof的结果永远不应该改变，使其更加可靠。如果是这样，那么您可能会遇到更大的问题。对象[property]==void 0也会起作用，因为void运算符的计算结果总是未定义的。请参阅。为什么不仅仅是对象中的属性&&object[property]==undefined？未定义的属性可能会被其他人覆盖。由于undefined只是值未定义的全局对象的一个属性，您可以编写undefined=true，现在object[property]==undefined将返回false。现代浏览器不允许未定义为不可写，但仍然允许。undefined也不是保留字，所以我想您也可以创建一个名为undefined的局部变量。typeof的结果永远不应该改变，使其更加可靠。如果是，那么您可能会遇到更大的问题。object[property]===void 0也会起作用，因为void运算符的计算结果总是未定义的。请参阅。