Implementing Array.prototype.concat in JavaScript

The concat() method is a fundamental JavaScript array method used to merge two or more arrays. It returns a new array containing the elements of the original arrays, without modifying the original arrays themselves. Implementing this method from scratch is a great exercise in understanding array manipulation and prototype inheritance in JavaScript.

Problem Description

Your task is to implement the concat() method as a function that can be added to the Array.prototype. This function should take any number of arrays as arguments and return a new array containing all the elements from those arrays, in the order they were provided. The original arrays should remain unchanged.

Key Requirements:

Prototype Extension: The implementation must extend the Array.prototype object.
New Array Creation: The function must return a new array. It should not modify the original arrays passed as arguments.
Multiple Arguments: The function should accept any number of array arguments.
Non-Array Arguments: If any argument is not an array, it should be treated as a single element and added to the resulting array.
Deep Copy (Not Required, but good to consider): While not strictly required for this challenge, consider how your implementation would behave if the arrays contained objects. A true deep copy would ensure that the objects themselves are not referenced, but for this challenge, simply copying the references is acceptable.

Expected Behavior:

The concat() method should behave identically to the built-in JavaScript concat() method.

Edge Cases to Consider:

Empty arrays as input.
No arguments passed to the function.
Arguments that are not arrays (e.g., numbers, strings, booleans, objects).
Arrays containing other arrays (nested arrays).
Arrays containing null or undefined values.

Examples

Example 1:

Input: [1, 2, 3].concat([4, 5, 6])
Output: [1, 2, 3, 4, 5, 6]
Explanation: The first array [1, 2, 3] is concatenated with the second array [4, 5, 6], resulting in a new array containing all elements in order.

Example 2:

Input: [1, 2].concat([3], [4, 5], 6)
Output: [1, 2, 3, 4, 5, 6]
Explanation: The first array [1, 2] is concatenated with the array [3], then with the array [4, 5], and finally with the single element 6.

Example 3:

Input: [1, 2].concat([])
Output: [1, 2]
Explanation: Concatenating with an empty array should return a copy of the original array.

Example 4:

Input: [].concat([1, 2], [3])
Output: [1, 2, 3]
Explanation: Concatenating an empty array with other arrays should return a new array containing the elements of the other arrays.

Constraints

The implementation must extend Array.prototype.
The function must return a new array.
The function must handle any number of arguments.
Non-array arguments should be treated as single elements.
The time complexity should be O(n), where n is the total number of elements in all arrays being concatenated.

Notes

Remember that Array.prototype is a shared object. Be careful not to overwrite existing methods. Consider using a namespace or prefix to avoid conflicts.
You can use the spread operator (...) to simplify the creation of the new array, but ensure you understand how it works.
Think about how to iterate through the arguments and handle different data types appropriately.
Testing your implementation thoroughly with various edge cases is crucial.