TIL: The odd behaviour of isNaN and isFinite

I've known for some time that the parseFloat, parseInt, isNaN and isFinite functions in JavaScript exist both as methods on the global object and as static methods on the Number constructor (e.g. Number.parseFloat). I've also known that parseFloat and parseInt are equivalent to Number.parseFloat and Number.parseInt, respectively. Naturally, I've always assumed that isNaN and Number.isNaN are equivalent and that so are isFinite and Number.isFinite. But I learnt today that that's not the case :(

It turns out Number.isNaN tells you if a value is the number NaN, while isNaN tells you if a value, when coerced to a number, is the number NaN. That is:

Number.isNaN(NaN) === true;
Number.isNaN(1) === false;
Number.isNaN("abc") === false;
Number.isNaN({}) === false;

isNaN(NaN) === true;
isNaN(1) === false;
isNaN("abc") === true; // because 'abc' becomes NaN when coerced with Number('abc')
isNaN({}) === true;

Similarly, Number.isFinite tells you if a value is a finite number, while isFinite tells you if a value, when coerced to a number, is a finite number:

Number.isFinite(123) === true;
Number.isFinite(Infinity) === false;
Number.isFinite(NaN) === false;
Number.isFinite("abc") === false;
Number.isFinite("123") === false;

isFinite(123) === true;
isFinite(Infinity) === false;
isFinite(NaN) === false;
isFinite("abc") === false;
isFinite("123") === true; // because '123' becomes the finite number 123 when coerced with Number('123')

I find the static Number methods more intuitive than the global ones, since they behave as I would expect of functions named "isNaN" and "isFinite".

Out of curiosity, I did a quick search online to find why these methods differ. All I could find was that the static methods were introduced in ES6, while the global ones were introduced earlier. I didn't however find any discussion on the rationale for the newer static methods. MDN recommends using the static methods to avoid surprises, so my guess is that the static methods were added because developers pre-ES6 used to complain about the global methods.