JavaScript Range Generator

This challenge involves creating a custom range function in JavaScript. Similar to Python's range or the spread syntax for ranges in other languages, this function will generate an array of numbers within a specified sequence. This is a fundamental operation useful for iterating over specific sets of numbers in loops, creating data for charts, or any scenario where you need a predictable sequence of integers.

Problem Description

You need to implement a JavaScript function named range that accepts one, two, or three arguments and returns an array of numbers. The function should mimic the behavior of a range generator.

Function Signature: range(stop) range(start, stop) range(start, stop, step)

Key Requirements:

1. One Argument (range(stop)): If only one argument is provided, it represents the stop value. The range should start from 0 (inclusive) and go up to, but not including, the stop value, with a default step of 1.
2. Two Arguments (range(start, stop)): If two arguments are provided, the first is start (inclusive) and the second is stop (exclusive). The step defaults to 1.
3. Three Arguments (range(start, stop, step)): If three arguments are provided, they represent start (inclusive), stop (exclusive), and step.
4. Step Behavior:
   • A positive step generates numbers in ascending order.
   • A negative step generates numbers in descending order.
5. Empty Range: If the start value is greater than or equal to the stop value when step is positive, or if start is less than or equal to stop when step is negative, the function should return an empty array.
6. Integer Steps: The step argument should be an integer. Non-integer steps are not explicitly required to be handled for this challenge, but consider how they might behave.

Expected Behavior:

• The returned value must be an array of numbers.
• The start value is always included in the range.
• The stop value is never included in the range.
• The sequence should continue as long as the current number is "before" the stop value, considering the direction of the step.

Edge Cases to Consider:

• stop value being 0 or negative when only stop is provided.
• start and stop values being the same.
• step being 0 (this would lead to an infinite loop if not handled carefully; for this challenge, treat a step of 0 as invalid or resulting in an empty array if start !== stop).
• Floating-point numbers for start and stop (the challenge primarily focuses on integers, but consider how it might behave).

Examples

Example 1:

Input: range(5)
Output: [0, 1, 2, 3, 4]
Explanation: Starts at 0, stops before 5, with a step of 1.

Example 2:

Input: range(2, 7)
Output: [2, 3, 4, 5, 6]
Explanation: Starts at 2, stops before 7, with a step of 1.

Example 3:

Input: range(1, 10, 2)
Output: [1, 3, 5, 7, 9]
Explanation: Starts at 1, stops before 10, with a step of 2.

Example 4:

Input: range(10, 2, -2)
Output: [10, 8, 6, 4]
Explanation: Starts at 10, stops before 2, with a step of -2.

Example 5:

Input: range(5, 5)
Output: []
Explanation: Start and stop are the same, resulting in an empty range.

Example 6:

Input: range(1, 1)
Output: []
Explanation: Start and stop are the same, resulting in an empty range.

Example 7:

Input: range(5, 0)
Output: []
Explanation: With a positive default step of 1, start is greater than stop, so the range is empty.

Example 8:

Input: range(0, 5, -1)
Output: []
Explanation: With a negative step, start is less than stop, so the range is empty.

Constraints

• The start, stop, and step arguments will be numbers.
• The step argument, if provided, will be an integer.
• The absolute value of step will not exceed 1000.
• The stop value will not be an arbitrarily large number that could cause memory issues in typical execution environments for small step sizes.
• A step of 0 should be handled gracefully, ideally resulting in an empty array unless start === stop.

Notes

• Consider how you will handle the different numbers of arguments passed to the function.
• Think carefully about the loop termination condition, especially when dealing with negative steps and floating-point numbers (though the primary focus is on integers).
• Ensure your implementation is efficient and avoids unnecessary operations.