Implementing Array.prototype.join in JavaScript

The built-in Array.prototype.join() method is a fundamental tool for converting an array into a string. This challenge asks you to implement this method yourself, reinforcing your understanding of array manipulation and string concatenation in JavaScript. Successfully completing this challenge demonstrates a solid grasp of JavaScript's core functionalities.

Problem Description

You are tasked with implementing the join() method directly on the Array.prototype. This means you'll be adding a new function to the prototype of the Array object, making it available to all arrays. The join() method takes an optional argument, the separator, which specifies the string to use to separate the array elements in the resulting string. If no separator is provided, a comma (,) is used by default.

What needs to be achieved:

• Create a function named join and add it to Array.prototype.
• This function should iterate through the array and concatenate its elements into a single string.
• The function should use the provided separator string between each element.
• If no separator is provided, the function should use a comma (,) as the default separator.
• Empty array elements should be converted to empty strings.

Key Requirements:

• The implementation must be robust and handle various input types correctly.
• The implementation should not rely on the built-in join() method.
• The implementation should be efficient for reasonably sized arrays.

Expected Behavior:

• When called on an array, the join() method should return a string containing all the array elements joined by the specified separator.
• If the array is empty, the method should return an empty string.
• If the separator is an empty string, the elements should be concatenated directly without any separators.

Edge Cases to Consider:

• Empty arrays.
• Arrays with empty strings as elements.
• Arrays with non-string elements (they should be converted to strings).
• Null or undefined separator (should default to a comma).
• Separator that is a string containing special characters.

Examples

Example 1:

Input: ['Hello', 'World', '!']
Output: "Hello,World,!"
Explanation: The array elements are joined with the default comma separator.

Example 2:

Input: ['apple', 'banana', 'cherry']
Output: "apple-banana-cherry"
Explanation: The array elements are joined with the hyphen separator.

Example 3:

Input: []
Output: ""
Explanation: An empty array returns an empty string.

Example 4:

Input: [1, 2, 3]
Output: "1,2,3"
Explanation: Non-string elements are converted to strings before joining.

Example 5:

Input: ['a', 'b', 'c']
Output: "abc"
Explanation: An empty string separator concatenates elements directly.

Constraints

• The input array can contain any number of elements (0 to 10000).
• The separator can be any string, including an empty string, null, or undefined.
• Array elements can be of any data type; they should be converted to strings.
• The implementation should have a time complexity of O(n), where n is the number of elements in the array.

Notes

• Remember that you are modifying the Array.prototype. Be mindful of potential conflicts with other libraries or code that might also modify the prototype.
• Consider using a for loop or forEach to iterate through the array.
• The toString() method can be helpful for converting non-string elements to strings.
• Handle the case where the separator is null or undefined gracefully by defaulting to a comma.