JavaScript中的对象相等性是什么

JavaScript为我们提供了许多检查两个对象是否相等的方法。让我们来演示如何检查两个对象是否相等。

有三种类型的相等性 –

• 引用相等性。
• 浅相等性。
• 深相等性。

  引用相等性： 当两个对象的指针相同时，或者运算符是同一对象实例时，我们可以说两个对象是引用相等的。

我们可以通过以下3种方式检查引用相等性：

• ===（三等号）运算符或严格相等运算符。严格相等指两个值的相等性。如果两个值具有相同的类型，则认为它们相等。
• ==（双等号）是松散相等运算符。它将两个值转换为公共类型，然后检查它们是否相等。
• object.is() 函数。

  ==运算符：

Javascript

let a = 1;
let b = 1;
console.log(a == b); // true
let c = 10;
let d = "10";
console.log(c == d); // true
 
 
const name1 = {
    first_name: "sarah",
};
 
const name2 = {
    first_name: "sarah",
};
 
console.log(name1 == name2); // false

输出

true
true
false

=== 运算符：

Javascript

let a = 1;
let b = 1;
 
console.log(a === b); // true
let c = 10;
let d = "10";
 
console.log(c === d); // false
 
const name1 = {
    first_name: "sarah",
};
 
const name2 = {
    first_name: "sarah",
};
 
console.log(name1 === name2); // false

输出

true
false
false

object.is() 方法：

JavaScript

let a = 1;
let b = 1;
 
let c = 10;
let d = "10";
 
console.log(Object.is(c, d)); // false
console.log(Object.is(a, b)); // true
console.log(Object.is(a, a)); // true
 
const name1 = {
    first_name: "sarah",
};
 
const name2 = {
    first_name: "sarah",
};
 
console.log(Object.is(name1, name2)); // false
console.log(Object.is(name1, name1)); // true

输出

false
true
true
false
true

浅相等：

• 对象的浅相等检查返回两个对象的属性列表，并进一步检查属性是否相等。
• 浅相等是当两个对象的键值相等时发生的一种相等类型。

示例： 在此示例中，shallowEqual函数比较obj1和obj2的属性。由于两个对象都具有相同的属性“a”和“b”，并且值相同，函数对obj1和obj2的比较返回true。

JavaScript

function shallowEqual(obj1, obj2) {
    const keys1 = Object.keys(obj1);
    const keys2 = Object.keys(obj2);
 
    if (keys1.length !== keys2.length) {
        return false;
    }
 
    for (let key of keys1) {
        if (!obj2.hasOwnProperty(key) || obj1[key] !== obj2[key]) {
            return false;
        }
    }
 
    return true;
}
 
const obj1 = { a: 1, b: 2 };
const obj2 = { a: 1, b: 2 };
const obj3 = { a: 1, b: 2, c: 3 };
 
console.log(shallowEqual(obj1, obj2));
// Output: true (Both objects have the same properties and values)
console.log(shallowEqual(obj1, obj3));
// Output: false (obj1 and obj3 have different number of properties)

输出

true
false

深度相等：

• 深度相等是一个递归的浅相等检查。
• 如果属性是对象，则递归地对这些对象进行检查。

示例： 在此示例中，deepEqual函数深度比较了obj1和obj2，包括嵌套属性。由于两个对象都具有相同的属性“a”和相同的值，以及嵌套属性“c”和相同的值，因此函数返回true以比较obj1和obj2。

Javascript

function deepEqual(obj1, obj2) {
    if (obj1 === obj2) {
      return true;
    }
   
    if (typeof obj1 !== 'object' || obj1 === null ||
        typeof obj2 !== 'object' || obj2 === null) {
      return false;
    }
   
    const keys1 = Object.keys(obj1);
    const keys2 = Object.keys(obj2);
   
    if (keys1.length !== keys2.length) {
      return false;
    }
   
    for (let key of keys1) {
      if (!obj2.hasOwnProperty(key) || !deepEqual(obj1[key], obj2[key])) {
        return false;
      }
    }
   
    return true;
  }
   
  const obj1 = { a: 1, b: { c: 2 } };
  const obj2 = { a: 1, b: { c: 2 } };
  const obj3 = { a: 1, b: { c: 3 } };
   
  console.log(deepEqual(obj1, obj2)); 
  // Output: true (Both objects have the same properties 
  //and nested properties with the same values)
  console.log(deepEqual(obj1, obj3)); 
  // Output: false (The nested property "c" 
  //has different values in obj1 and obj3)

输出

true
false