Deep Object Equality Check in JavaScript

Determining if two JavaScript objects are equal can be surprisingly tricky. The standard == and === operators perform shallow comparisons, only checking if the top-level properties are equal by reference, not by value. This challenge asks you to implement a function that performs a deep comparison, recursively checking the equality of all nested properties.

Problem Description

You need to write a JavaScript function called deepEquals that takes two objects as input and returns true if the objects are deeply equal, and false otherwise. Deep equality means that the objects have the same properties, and the values of those properties are also deeply equal. This includes checking nested objects and arrays.

Key Requirements:

• The function must handle nested objects and arrays correctly.
• The function must return true if the objects are identical (same memory location).
• The function must return false if the objects have different keys.
• The function must return false if corresponding values are not deeply equal.
• The function should handle primitive types (string, number, boolean, null, undefined, symbol) correctly.
• The function should handle null and undefined values appropriately.

Expected Behavior:

The function should return true if the two objects are deeply equal and false otherwise.

Edge Cases to Consider:

• Objects with different numbers of properties.
• Objects with properties that have different types.
• Circular references (though this challenge doesn't require handling them, be aware of the potential issue).
• null and undefined values.
• Empty objects.
• Arrays as values within objects.

Examples

Example 1:

Input: { a: 1, b: 2 }
Input: { a: 1, b: 2 }
Output: true
Explanation: Both objects have the same properties with the same values.

Example 2:

Input: { a: 1, b: { c: 2 } }
Input: { a: 1, b: { c: 2 } }
Output: true
Explanation: Both objects have the same properties, and the nested object 'b' is also deeply equal.

Example 3:

Input: { a: 1, b: 2 }
Input: { a: 1, b: 3 }
Output: false
Explanation: The values of property 'b' are different.

Example 4:

Input: { a: 1, b: 2 }
Input: { a: 1, c: 2 }
Output: false
Explanation: The objects have different keys.

Example 5:

Input: { a: 1, b: null }
Input: { a: 1, b: null }
Output: true
Explanation: Handles null values correctly.

Constraints

• The input objects can contain any valid JavaScript data types as values (including nested objects, arrays, primitives, null, and undefined).
• The function must be implemented recursively.
• The function should be reasonably efficient for objects of moderate size (up to 100 properties). Performance is not the primary focus, but avoid excessively inefficient algorithms.
• The function should not modify the input objects.

Notes

• Consider using recursion to traverse the objects and compare their properties.
• Be mindful of the different types of values you might encounter and how to compare them appropriately.
• Think about how to handle the base cases of the recursion (e.g., when you reach a primitive value or an empty object).
• The order of properties in the objects does not matter for deep equality.
• You can assume that the inputs are always objects (or null/undefined). No need to add explicit type checking for that.