Deep Array Cloning in JavaScript

Creating copies of arrays is a fundamental operation in programming. However, in JavaScript, simply assigning one array to another doesn't create a true copy; it creates a reference. This means changes to one array will affect the other. This challenge focuses on implementing a function that creates a deep clone of an array, ensuring that nested arrays and objects are also copied, not just referenced.

Problem Description

You are tasked with writing a JavaScript function called deepCloneArray that takes an array as input and returns a completely independent copy of that array. A deep clone means that all elements within the array, including nested arrays and objects, are also cloned, not just referenced. Modifying the cloned array should not affect the original array, and vice versa.

Key Requirements:

• The function must handle arrays containing primitive data types (numbers, strings, booleans, null, undefined).
• The function must handle arrays containing nested arrays.
• The function must handle arrays containing objects.
• The function must return a new array.
• The function should not modify the original array.

Expected Behavior:

The deepCloneArray function should recursively traverse the input array and create new copies of all elements. For primitive types, this means creating a new variable with the same value. For arrays and objects, this means creating a new array/object and recursively cloning its elements.

Edge Cases to Consider:

• Empty array: []
• Array with only primitive types: [1, "hello", true]
• Array with nested arrays: [1, [2, 3], 4]
• Array with objects: [ {a: 1}, {b: 2} ]
• Array with a mix of primitive types, nested arrays, and objects: [1, [2, {c: 3}], "hello"]
• Circular references (though this challenge doesn't explicitly require handling them, be aware of the potential issue).

Examples

Example 1:

Input: [1, 2, 3]
Output: [1, 2, 3]
Explanation: A simple array of numbers is cloned.

Example 2:

Input: [1, [2, 3], 4]
Output: [1, [2, 3], 4]
Explanation: A nested array is cloned.  The inner array [2, 3] is also a new array.

Example 3:

Input: [{a: 1}, {b: 2}]
Output: [{a: 1}, {b: 2}]
Explanation: An array of objects is cloned. Each object is a new object with the same properties and values.

Example 4:

Input: [1, [2, {c: 3}], "hello"]
Output: [1, [2, {c: 3}], "hello"]
Explanation: A mixed array with primitives, nested arrays, and objects is cloned.

Constraints

• The input will always be a JavaScript array.
• The array may contain any valid JavaScript data types (primitive types, arrays, objects, null, undefined).
• The function should be reasonably performant for arrays of moderate size (up to 1000 elements). While extreme optimization isn't required, avoid unnecessarily inefficient approaches.
• The function should not use external libraries or built-in methods like JSON.parse(JSON.stringify(arr)) as the solution. The goal is to implement the deep cloning logic yourself.

Notes

Consider using recursion to traverse the array and its nested structures. You'll need to check the type of each element to determine whether to create a new primitive value or recursively clone the element. Think about how to handle objects and arrays differently. Remember that the goal is to create a completely independent copy.