Why was Math.max(...) designed to only support comma separation?

If you don't like to use the spread operator, there's always .apply: Math.max.apply(null, [10, 25, 7, 40]). If that is better is a matter of taste (IMHO: No).

Sadly, the world does not always live up to ones expectations and sometimes things are just the way they are.

Math.max has been widely available since July 2015. The spread operator has been widely available since October 2015. So the operator did not exist when the function was implemented. However, you can do something like this in your project:

Math.Max = function(array) {
    return Math.max(...array);
}
console.log(Math.Max([4,2,6,2]));

So you will be able to call Math.Max which under the hood will call Math.max and handle your array.

Math.max wasn’t designed “wrong”—it was designed early.

• It predates modern JS patterns

• It follows math notation

• Spread exists to bridge old APIs with modern code

• Overloading with arrays would harm predictability and performance

Spread exists to bridge old APIs with modern code

The spread operator is just modern syntactic sugar; you could always use .apply to "bridge old APIs".

I would not recommend that. Just use .... It's hardly any more inconvenient, but it's widely understood and available.

Modifying builtins to add new methods always has the potential for problems. Since this will be a polyfill, you'd need to make sure you're not polyfilling this hack in two different places, possibly in different ways. It also looks like a typo to the uninitiated and is unexpected.

The spread operator makes readability unnecessarily difficult.

I guess that's a matter of opinion because I love it. It avoids having to use the apply method like in the old days. It's also very readable as it succulently shows that the parameter is an expanded iterable.

Regardless, neither one of these seem unnecessarily difficult:

• JavaScript Math.max(...array)

• Python max(array)

Python is one of the few languages that will accept an iterable as a max parameter.

That "answer" not only contains wrong information (the Math object has at least been in the standard since 1997 and is "widely available" since long before 2015), it also encourages bad practice (ever heard of "do not modify objects you don't own"? The suggested practice is the reason why Array.prototype.flat is not named .flatten as it was initially planned - see for more information and why modifying built-ins is a big no-no)