Javascript比较对象中的值

deepEqual函数应该接受两个值，看看它们是否完全相同。第一次和第二次测试的结果与预期一致。我合并递归调用的方式是否有问题

function deepEqual(obj1, obj2) {
  if (typeof obj1 == 'object' && typeof obj1 !== null && typeof obj2 == 'object' && typeof obj2 !== null) {
    if (obj1.length != obj2.length) {return false;}
    for (var prop in obj1) {
      if (typeof obj1[prop] == 'object') {deepEqual(obj1[prop], obj2[prop]);}
      if (obj1[prop] != obj2[prop]) {return false;}
    }
    return true;
  } else if (obj1 === obj2) {return true;}
  else {return false;}
}

var obj = {here: {is: "an"}, object: 2};
console.log(deepEqual(obj, obj));
// → true -> true
console.log(deepEqual(obj, {here: 1, object: 2}));
// → false -> false
console.log(deepEqual(obj, {here: {is: "an"}, object: 2}));
// → true -> false

我合并递归调用的方式是否有问题

function deepEqual(obj1, obj2) {
  if (typeof obj1 == 'object' && typeof obj1 !== null && typeof obj2 == 'object' && typeof obj2 !== null) {
    if (obj1.length != obj2.length) {return false;}
    for (var prop in obj1) {
      if (typeof obj1[prop] == 'object') {deepEqual(obj1[prop], obj2[prop]);}
      if (obj1[prop] != obj2[prop]) {return false;}
    }
    return true;
  } else if (obj1 === obj2) {return true;}
  else {return false;}
}

var obj = {here: {is: "an"}, object: 2};
console.log(deepEqual(obj, obj));
// → true -> true
console.log(deepEqual(obj, {here: 1, object: 2}));
// → false -> false
console.log(deepEqual(obj, {here: {is: "an"}, object: 2}));
// → true -> false

是的，您正在丢弃它的返回值。您应该检查它的返回值，如果它为false，则尽早返回

false

if (typeof obj1[prop] == 'object') {
    if (!deepEqual(obj1[prop], obj2[prop])) {
        return false;
    }
}

---

旁注：代码中还有几个其他问题。我不打算对它进行全面的回顾，但例如，上面一行后面的

if

测试

obj1[prop]

，看看它是否真的应该是

，否则如果
，例如：

if (typeof obj1[prop] == 'object') {
    if (!deepEqual(obj1[prop], obj2[prop])) {
        return false;
    }
} else if (obj1[prop] != obj2[prop]) {
//^^^^------------------------------------------ here
    return false;
}

我合并递归调用的方式是否有问题

function deepEqual(obj1, obj2) {
  if (typeof obj1 == 'object' && typeof obj1 !== null && typeof obj2 == 'object' && typeof obj2 !== null) {
    if (obj1.length != obj2.length) {return false;}
    for (var prop in obj1) {
      if (typeof obj1[prop] == 'object') {deepEqual(obj1[prop], obj2[prop]);}
      if (obj1[prop] != obj2[prop]) {return false;}
    }
    return true;
  } else if (obj1 === obj2) {return true;}
  else {return false;}
}

var obj = {here: {is: "an"}, object: 2};
console.log(deepEqual(obj, obj));
// → true -> true
console.log(deepEqual(obj, {here: 1, object: 2}));
// → false -> false
console.log(deepEqual(obj, {here: {is: "an"}, object: 2}));
// → true -> false

是的，您正在丢弃它的返回值。您应该检查它的返回值，如果它为false，则尽早返回
false

if (typeof obj1[prop] == 'object') {
    if (!deepEqual(obj1[prop], obj2[prop])) {
        return false;
    }
}


旁注：代码中还有几个其他问题。我不打算对它进行全面的回顾，但例如，上面一行后面的
if
测试
obj1[prop]
，看看它是否真的应该是
，否则如果
，例如：

if (typeof obj1[prop] == 'object') {
    if (!deepEqual(obj1[prop], obj2[prop])) {
        return false;
    }
} else if (obj1[prop] != obj2[prop]) {
//^^^^------------------------------------------ here
    return false;
}

难以置信你跑得这么快：）太好了@所以原始代码不能从if语句返回任何东西。但是，函数是否仍然能够完成
for
循环并最终返回true？我还觉得连续的
if
语句是按顺序运行的。在这种情况下，它只是重复了吗？@James：缺少的
else
的问题是，如果
obj1[prop]
和
obj2[prop]
是对象，它们不是同一个对象，在执行
deepEquals
调用后，您将转到
if（obj1[prop]！=obj2[prop]）
检查，这将是真的（因为它们是不同的对象）并且你会返回
false
@T.J.Crowder我有点困惑。如果在执行
deepEquals
后两个对象不一样，那么程序返回
false
不是正确的吗？@James:我假设
deepEquals
的目标是检查等价性。例如，
var a={foo:“bar”}；var b={foo:“bar”}；console.log（deepEquals（a，b））；//true
这不是对象引用检查的内容；
=
和
==
检查的内容；它们检查标识（都是对同一对象的引用），而不是等价性（这两个不同的对象是否彼此等效，例如，它们是否具有相同的属性和相同的值）。难以置信，您在这方面的速度是如此之快：）很好！@T.J.Crowder，因此原始代码将无法从if语句返回任何内容。然而，函数是否仍然能够完成
for
循环并最终返回true？我还感觉到连续的
if
语句只是按顺序运行。在这种情况下，它只是重复吗？@James:缺少的
else
的问题是，如果
obj1[prop]
和
obj2[prop]
是对象，并且它们不是同一个对象，在执行
deepEquals
调用后，您将转到
if（obj1[prop]！=obj2[prop]）
检查，这将是真的（因为它们是不同的对象）你会返回
false
@T.J.Crowder我有点困惑。如果执行
deepEquals
后的两个对象不一样，那么程序返回
false
不是正确的吗？@James:我假设
deepEquals
的目标是检查等价性。例如，
var a={foo:'bar}；var b={foo:'bar}；console.log（deepEquals（a，b））；//true
这不是使用对象引用检查的
=
和
==
；它们检查标识（都是对同一对象的引用），而不是等价性（两个不同的对象是否彼此等价，例如，它们是否具有相同的属性和相同的值）.@splaten它对对象不起作用。它只是测试引用的相等性。@splaten:OP显然是在测试等价性，而不是身份。在将obj2中的“prop”传递到deepEqual之前，您应该测试它是否存在。@splaten它对对象不起作用。它只是测试引用的相等性。@splaten:OP显然是在尝试不存在o测试等效性，而不是身份。在将“prop”传递到deepEqual之前，应测试obj2中是否存在“prop”。