Thanks for all the comments folks and particularly those of you who've taken the time to explain why js is behaving the way it is. To be honest, I just thought this stuff was amusing, I'm enjoying watching the discussion unfold here and onreddit.
Here's a fun one that I didn't put in:
js> 3>2>1 falseI would expect it to think I meant
3>(2>1)and 3 is greater than true if squint at it right. However, it actually evaluates to
js> (3>2)>1 falsewhich means
js> true>1
false
var arrayMap = [1]; arrayMap["stuff"] = "hi"; arrayMap["moreStuff"] = "there"; arrayMap.length == 1; // is true arrayMap["stuff"] == "hi";// is true arrayMap.toString(); // "1"
check it's type...(the fact I wrote this means it's not what you would guess)
js> var a = []+[] undefined js> typeof a 'string'that's a little odd to me.
that is really misleading, remember when I said array plus something is merging strings? > ['hi']+{} 'hi[object Object]'
what your example has actually done is printed the string notation for an object and put an empty string in front of it. That's totally normal/expected behavior.
------------------
With this next one, it is odd but it is still expected behavior
js> true+true===2 true js> true-true===0 true
this isn't that surprising because you are forgetting something really important, boolean + boolean will be coerced into an int to fit your strict need for addition.
js> true+true 2 js> false+true 1
Therefore if you compare the results it will not only equal the number 2 but also be a number itself!
js>true+true === 1+1 true
I hope this helps everyone understand these oddities that aren't specific to just javascript.
js> Array(3)==",," true
That is fully expected, you are comparing the value of an array which would be represented as [",,"] so without checking the types, this is exactly what you should get.
ex.
js>Array(3)===",," false------------------
The issue with something like
js> 9999999999999999 10000000000000000
is that the largest exact number available is 9007199254740992 due to the fact that javascript uses double-precision floating-point numbers. http://ecma262-5.com/ELS5_HTML.htm#Section_8.5
------------------
Now, there is a perfectly valid reason why this is an expected result:
js> 0.1+0.2==0.3 false
The issue is that the first subject of addition isn't actually just 0.1, it's actually
0.100000000000000005551
same with 0.2, it's actually value is
0.200000000000000011102
if you execute 0.1 it will say 0.1 due to the fact that javascript has a default precision size to show you which is the length of your input OR 1 if it's over 18.
If you execute 0.10000000000000006
it will return 0.10000000000000006
however
if you execute 0.100000000000000006 (one more precision)
it will return 0.1
Now, here is what is actually happening
js> (0.1).toPrecision(21) 0.100000000000000005551 js> (0.2).toPrecision(21) 0.200000000000000011102 js> (0.1+0.2).toPrecision(21) 0.300000000000000044409
Now that makes more sense, it was just hidden by the way JS chooses to show numbers. Python suffers from the same situation.
So in conclusion 0.1+0.2 is not equal to 0.3, it's equal to 0.300000000000000044409
js> 0.1+0.2 == 0.300000000000000044409 true------------------
js> Math.max()>Math.min() false js> Math.max() ['hello'] + [' '] + ['world'] 'hello world'
So []+[] returning a string is normal, but what about when you check the typeof []+[] ...?
js> typeof []+[] 'object'welp, that's sure not a string BUT, what about when you assign []+[] to a variable and
![] === false !+[] === true []+[] === "" ![]+[] === "false" !+[]+[] === "true" !+[]+[]+![] === "truefalse" "truefalse".length === 9
TIL, by analysis of results here, that in javascript:
Math.min() == InfinityThat's kind of a high bar to put on the smallest value of nothing. Very zen in its way.
Math.max()>Math.min() === false
makes sense if you're aware of the defined behaviour for these functions:
Math.min()...If no arguments are given, the result is Infinity.
Math.max()...If no arguments are given, the result is - Infinity.
Now, as to why those were the decisions they made, your guess is as good as mine - but I guess they're just as reasonable as any other decision for when you ask for the max or min of an undefined value.
@ lolkittens -
typeof []+[] === "object"because
typeof [] === "object"and
"object" + [] === "object"; what you probably wanted to be evaluating is
typeof([]+[]), which most definitely IS "string"; in other words, the keyword
typeofhas higher precedence than
+, so you were evaluating
(typeof [])+[].
That NaN is not equal to itself is specified in the IEEE specs. Any programming language should give the same outcome as JavaScript here.
Gary Bernhardt has an amusing screencast about the topic if that's what your looking for. https://www.destroyallsoftware.com/talks/wat