Deep Cloning Objects in JavaScript

Deep cloning an object is a fundamental skill in JavaScript, crucial for creating independent copies of complex data structures. It ensures that modifications to the clone do not affect the original object, and vice versa. This challenge will test your ability to implement a robust deep cloning function that handles nested objects, arrays, and primitive data types.

Problem Description

You are tasked with creating a JavaScript function called deepClone that takes an object or array as input and returns a completely independent deep copy. A deep copy means that all nested objects and arrays within the original structure are also copied, creating a new, separate instance of each. Modifying the cloned object should not impact the original, and vice versa.

Key Requirements:

• Handles Objects and Arrays: The function must correctly deep clone both objects and arrays.
• Recursive Cloning: Nested objects and arrays must be recursively deep cloned.
• Primitive Data Types: Primitive data types (numbers, strings, booleans, null, undefined, symbols) should be copied by value.
• Circular References: The function must handle circular references gracefully, preventing infinite loops. If a circular reference is detected, the clone should retain a reference to the original object at that point, rather than attempting to re-clone it.
• Functions: Functions within the object/array should not be cloned. They should be copied by reference.

Expected Behavior:

The deepClone function should return a new object or array that is structurally identical to the input but contains entirely new instances of all objects and arrays.

Edge Cases to Consider:

• Null or Undefined Input: Handle cases where the input is null or undefined. Return null if the input is null, and undefined if the input is undefined.
• Primitive Input: If the input is a primitive type, return the input directly (no cloning needed).
• Circular References: As mentioned above, circular references must be handled to avoid infinite recursion.
• Date Objects: Date objects should be cloned correctly, preserving their values.
• Regular Expressions: Regular expressions should be cloned correctly, preserving their patterns and flags.

Examples

Example 1:

Input: { a: 1, b: { c: 2, d: [3, 4] } }
Output: { a: 1, b: { c: 2, d: [3, 4] } }
Explanation: A new object is created with the same structure and values. Modifying the cloned object's `b.c` will not affect the original.

Example 2:

Input: [1, 2, [3, {x: 4}], 5]
Output: [1, 2, [3, {x: 4}], 5]
Explanation: A new array is created with the same elements.  The nested object `{x: 4}` is also deep cloned.

Example 3: (Circular Reference)

Input: let obj = { a: 1 }; obj.b = obj; deepClone(obj)
Output: { a: 1, b: { a: 1, b: [Circular] } }  (or similar representation of circular reference)
Explanation: The clone retains a reference to the original object at the point of the circular reference.  The exact representation of the circular reference in the output may vary depending on the JavaScript engine.

Constraints

• Input Size: The input object/array can contain up to 10 levels of nesting.
• Input Types: The input can be any JavaScript object, array, primitive type, null, or undefined.
• Performance: The function should complete within a reasonable time frame (e.g., less than 1 second) for typical object/array sizes. While optimization is encouraged, correctness is the primary concern.
• No External Libraries: You are not allowed to use external libraries like Lodash or jQuery. You must implement the deep cloning logic yourself.

Notes

• Consider using recursion to traverse the object/array structure.
• A Set or WeakSet can be helpful for detecting and handling circular references.
• Pay close attention to the different data types you encounter and how they should be handled during cloning.
• Think about how to handle functions – they should be copied by reference, not cloned.
• Date and RegExp objects require special handling to ensure their values are preserved.