The one option that is mandated by an ISO standard.
Besides, if max and min are going to have a value without any parameter, it has to be exactly those Javascript uses. Unless you have a type that define other bounds for your numbers. And null always have a pointer type (that is object in Javascript), for the same reason that NaN always have a number type.
The only one that is bad on that list is D.
typeof null === "object"
was actually a bug in the early implementations, and they decided to keep it in the spec: https://2ality.com/2013/10/typeof-null.html(see the comment from Brendan Eich)
Tony Hoare: “Introducing NULL was a billion-dollar mistake”
Brendan Eich: “Hold my undefined”
We had one
null
, yes. But what about secondnull
?
Maybe D is too single quotes
0 == ''
“This comparison appears to be unintentional”
D…Deez nutz!
If you thought this was fun you might like https://jsisweird.com/ with similar questions
Option C. The value
NaN
compares unequal to every value, even itself. This breaks one of the rules of what equality even means (that every value must be equal to itself, the “reflexivity” axiom). It is for this reason (among others,equality“partial” equivalence between values of different types? 🤮) Rust needed to havePartialEq
. See IEEE 754 for more details.Why
typeof null
is"object"
? Because it is defined so: https://tc39.es/ecma262/multipage/ecmascript-language-expressions.html#sec-typeof-operator5. If
val
isnull
, return"object"
.As for the rationale behind the choice, it might have something to do with “Prototypal inherience” the language has. https://tc39.es/ecma262/multipage/overview.html#sec-objects
Every object created by a constructor has an implicit reference (called the object’s prototype) to the value of its constructor’s “prototype” property. Furthermore, a prototype may have a non-null implicit reference to its prototype, and so on; this is called the prototype chain.
We can understand this to mean that prototype chains are
null
terminated ;)For example:
> Object.getPrototypeOf({}) === Object.prototype true > Object.getPrototypeOf(Object.getPrototypeOf({})) null > Object.getPrototypeOf(null) TypeError: not an object
Uhh…
Now, let’s go to some abstract algebra. All good (closed) binary operations we deal with have an identity or neutral value. For example: addition has 0, multiplication has 1, boolean
and
hastrue
, booleanor
orxor
hasfalse
. Performing these operations with the neutral value does not change the other operand: for example,x + 0 == x
,a * 1 == a
,true && b == b
and so on. If you admitmin
andmax
as operators, you can see why ∞ and -∞ are the neutral values, respectively:min(∞, x) == x
andmax(-∞, y) == y
for every (real) value of x and y. Observe howArray.prototype.reduce
works (with its second argument) for inspiration on why and how all this matters: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceFor mathematicians: closed, because the operators are maps
S × S →S
, to exclude<
,etc. as they map to
Bool
. Oh, they are relations, bla bla … real numbers, we don’t want to deal with other total orders here, there should be some way to call orders that have both top and bottom values, complex numbers don’t have orders (usual ones, are there unusual ones?), bla bla blaAs for the last one, sigh… https://tc39.es/ecma262/multipage/abstract-operations.html#sec-islooselyequal
Oh, that
!
s in there aren’t booleannot
… they are… (looks it up) argh, read it yourself https://tc39.es/ecma262/multipage/notational-conventions.html#sec-returnifabrupt-shorthands