Which of these javascript expressions is false?

I'm no expert and I know that javascript is full of wtf moments, but please.. Let it be B

It's not gong to be B, it's it.

It is true. Math.min() returns positive Infinity when called with no arguments and Math.max() returns Negative Infinity when called with no arguments. Positive Infinity > Negative Infinity.
Math.min() works something like this
python

def min(numbers): r = Infinity for n in numbers: if n < r: r = n return r
I'm guessing there's a reason they wanted min() to be able to be called without any arguments but I'm sure it isn't a good one.
- So, the language isn't compiled (or wasn't originally) so they couldn't make min() be an error that only a developer saw, it has to be something that the runtime on the end-user system dealt with. So, it had to be assigned some value. Under those restrictions, it is the most mathematically sound value. It makes miniumum-exactly-2(x, min(<...>)) be exactly the same as min(x, <...>), even when the "<...>" has no values.
  As a developer, I see a lot of value in static analysis, including refusing to generate output for sufficiently erroneous results of static analysis, so I don't like using JS, and the language that I tinker with will definitely have a separate compilation step and reject the equivalent of min(). But, if I HAD to assign something like that a value, it probably would be a representation of infinity, if we had one (probably will due to IEEE floats).
  HTH
- I’m guessing there’s a reason they wanted min() to be able to be called without any arguments but I’m sure it isn’t a good one.
  It not a totally unreasonable definition. For example it preserves nice properties like min(a.concat(b)) == min([min(a), min(b)]).
  Obviously the correct thing to do is to return an optional type, like Rust does. But ... yeah I mean considering the other footguns in Javascript (e.g. the insane implicit type coersion) I'd say they didn't do too badly here.
js

Math.min() == Infinity Math.max() == -Infinity
Wtf is going on JS...
edit: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min
Its the min value of the input params, or Infinity.
- Math.min.length is 2, which weakly signals that it's designed to handle at least two parameters
  Why would they even define this value?
  Note: I’m not a js dev, do most functions have length?
- Its the min value of the input params, or Infinity.
  And the reason it's Infinity If there is no input, for better or worse, under the hood the method is assigning a variable, min, the highest value possible and then comparing it to each element in the list, reassigning it when it encounters an element lower than its value at the time. So it will obviously always be reassigned if there are any elements at all (if they're less than Infinity, I guess). But if there are no elements, it's never reassigned, and thus returns Infinity. It could have just signed min to the first element instead if Infinity, but that would lead to a runtime error when min was run without a function. If you're not going to throw a runtime error though, it makes sense for min to return Infinity because, what other number could you return that couldn't actually be the minimum
It's C, NaN is never equal to itself in floating point, that's not just a JS thing.
- Yep, it's C
Narrator: "It wasn't B."
Fun fact, even tho B is False, Math.min > Math.max is true
- That is not a fun fact. How do I unsubscribe :D
- But B is true
I also am not familiar with javascript anymore....precisely because of this, exact, insane bullshit.
B... and/or C... evaluating as FALSE are the only things that... should even kind of make sense, according to my brain.
Though at this point in my life, I have unironically had a good number of concussions and contusions, so ... well you'd think that would help with JS development.
Javascript is insanity, and I am still convinced it is at least 40% responsible for Notch losing his goddamned mind.
'null' is somehow an object. because fuck you, thats why!
Is... 0 == '' ... is that two single quotes ' ' ?
Or one double quote " ?
If... it is one double quote... that wouldn't even evaluate, as it would just be an empty string without a defined end...
But if it was two single quotes... that would just be a proper empty string... and because of forced type coercion, both 0 and '' are FALSE when compared with ==, but not when compared with ===, because that ignores forced type coercion...
https://www.w3docs.com/snippets/javascript/when-to-use-double-or-single-quotes-in-javascript.html
Oh my fucking god WHY?!
Just fucking use one special character to delimit strings!
Don't have two that don't work together and also behave differently even when you pick just one of them... GraaaghhH!
brb, figuring out where Larry Ellison lives...
- Notch? The guy who codes in java?
- I don't think my sanity can take all of these explanations.
  Though I just spotted one that's worse than null being an object ..
  
  typeof NaN "number"
  I mean, come on.. it's even in the fucking name!
  Edit - fixed capitalisation in 'NaN'
- It’s pretty easy to avoid all of these, mostly by using ===. Null being an object is annoying and is one of the reasons ‘typeof’ is useless, but there are other ways to accomplish the same thing.
  JavaScript has a lot of foot guns, but it’s also used by literally everyone so there is a lot of tooling and practice to help you avoid them.

It's C

No, it's Javascript, keep up
- Javascript is basically just C with some syntactical sugar, right? RIGHT?!?
Wtf? Min > Max???
- Math.min isn’t the minimum integer; it’s the minimum of a list (and max visa versa)… the min/max of an undefined list is the same… IDK what it is, but this probably the most reasonable of the “WTFs” they could have put there i think… other languages would throw an exception or not compile (which JS definitely SHOULD do instead of this, buuuuut lots of JS has aversions to errors)
  *edit: okay the curiosity was killing me: Math.min() is Infinity and Math.max() is -Infinity
- I always thought that NaN is required by IEEE rules to never equal any other number, including itself, because you can make NaN in different ways and this shouldn't result in equality or something, so C is wild but not javascript's fault.
  The other three being true is definitely javascript's insane fault, though.
- Completely wrong. I'm hoping this was a joke... :-D

That one wasn't the one I had issues with, since the concept is essentially the same across all languages. We say it's false because we can't conclusively say that it's true. Same as the reason why null != null in SQL.
- It also makes a lot of conditional expressions less complicated because comparisons of all kind against NaN return false.

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"
Maybe D is too single quotes 0 == ''
- "This comparison appears to be unintentional"
D...Deez nutz!

C

C++

C, because yes.

I'd say C too because that's the only one that would be True in a normal programming language and this is javascript so...
- It's not true in a normal programming language. If it is true in yours, you should stop using it immediately.
- probably not true in most other langauges. although I'm not well versed in the way numbers are represented in code and what makes a number "NaN", something tells me the technical implications of that would be quite bad in a production environment.
  the definitive way to check for NaN in JS would probably be something like
  
  // with `num` being an unknown value // Convert value to a number const res = Number(num); /* * First check if the number is 0, since 0 is a falsy * value in JS, and if it isn't, `NaN` is the only other * falsy number value */ const isNaN = res !== 0 && !res;
Can't be C, C is the true path.

I love the two lonely downvotes on this.

Merging the upvotes and downvotes is the best option
- nah, it's more fun this way.

If you thought this was fun you might like https://jsisweird.com/ with similar questions

Probably B?

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 have PartialEq. 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-operator

5 If val is null, 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:

js

    
> 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 has true, boolean or or xor has false. 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 admit min and max as operators, you can see why ∞ and -∞ are the neutral values, respectively: min(∞, x) == x and max(-∞, y) == y for every (real) value of x and y. Observe how Array.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/reduce

For 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 bla

As for the last one, sigh.. https://tc39.es/ecma262/multipage/abstract-operations.html#sec-islooselyequal

Oh, that !s in there aren't boolean not.. they are.. (looks it up) argh, read it yourself https://tc39.es/ecma262/multipage/notational-conventions.html#sec-returnifabrupt-shorthands