wtf.js

/* VT100 terminal reset (<ESC>c) */

console.log('\033c');

/* numbers comparations */

> '2' == 2
true

> '2' === 2
false

> [2] == 2
true

> [] + []
''

> [] == []
false

> typeof []
'object'

> [] == ![]
true

> +[] == +![]
true

/* null comparation */

> 0 > null
false

> 0 >= null
true

> 0 == null
false

> 0 <= null
true

> 0 < null
false

> typeof null
'object'

> null instanceof Object
false

/* checking array type */

> {}.toString.call([])
'[object Array]'

> function FooBar() {}
undefined

> {}.toString.call(new FooBar)
'[object Object]'

> (new FooBar).constructor == Foo
false

> [] instanceof Array
true

> Array.isArray([])
true

/* math */

> 999999999999999
999999999999999

> 9999999999999999
10000000000000000

> -9999999999999999
-10000000000000000

> 0.1 + 0.2 == 0.3
false

> 0.1 + 0.2
0.30000000000000004

> 3 > 2 > 1
false

> 3 > 2 >= 1
true

> '2' + 1
'21'

> '2' - 1
1

> '2' - -1
3

> 1/0
Infinity

> typeof Infinity
'number'

> 0 === -0
true

> 1/0
Infinity

> 1/-0
-Infinity

> Infinity == -Infinity
false

Number.MAX_VALUE
1.7976931348623157e+308

> 0 - 1
-1

> Number.MIN_VALUE < 0
false

> Number.MIN_VALUE
5e-324>

> Math.max(1,2,3)
3

> Math.min(1,2,3)
1

> Math.max() > Math.min()
false

> Math.max()
-Infinity

> Math.min()
Infinity

/* string */

> 'wtf' instanceof String
false

> typeof 'wtf'
'string'

> typeof String('wtf')
'string'

> String('wtf') === 'wtf'
true

> String('wtf') === new String('wtf')
false

> String('wtf') == new String('wtf')
true

> new String('wtf')
{ '0': 'w',
  '1': 't',
  '2': 'f' }

> new String('wtf').toString()
'wtf'

> 'wft' + 1
'wft1'

> 'wft' - 1
NaN

/* NaN */

> typeof NaN
'number'

> typeof 1138
'number'

> 1138 == 1138
true

> NaN == NaN
false

> isNaN('wft' - 1)
true

/* boolean math */

> true + false
1

> true + true == true
false

/* construct function */

> new 0xff.constructor.constructor('console.error("WTF")')()
WTF

> new Function('console.error("WTF")')()
WTF

/* typeof/instanceof */

> Array instanceof Array
false

> new Array instanceof Array
true

> Math instanceof Math
TypeError: Expecting a function in instanceof check, but got #<Object>
    at repl:1:18
    at REPLServer.self.eval (repl.js:110:21)
    at Interface.<anonymous> (repl.js:239:12)
    at Interface.emit (events.js:95:17)
    at Interface._onLine (readline.js:203:10)
    at Interface._line (readline.js:532:8)
    at Interface._ttyWrite (readline.js:761:14)
    at ReadStream.onkeypress (readline.js:100:10)
    at ReadStream.emit (events.js:98:17)
    at emitKey (readline.js:1096:12)
>

> '1' + '1' - '1' + '1' - '1' + '1' - '1'
1000

Few things could be explained and they are not at all WTFs. For example, 0.1 + 0.2 is not a WTF. You would get similar results in most of the language. And similarly, { } + [ ] >_<

Please watch this video on YouTube ( https://youtu.be/2pL28CcEijU ) before commenting anything here :)

3 > 2 > 1
false

3 > 2 >= 1
true
Interpreting from left to right, 3 > 2 evaluates to true.
The whole expression is false because (3 > 2) == true == 1 and hence 1 > 1 is false, but 1 >= 1 is true.

var count = 0;
var foo = () => {
	try { return 999; }
	finally { return ++count; }
};
console.log(foo(), count);

1 1

function sum(a, b) {
       return
              a + b; }
console.log(sum(1, 3));

undefined

+1 @thisisabdus
But if you want a hotfix , pass it toFixed method
Ex , to compare 0.1 and 0.2 so you need something like this : parseFloat(Number(0.1+0.2).toFixed(1)) === 0.3 -> true

> [10, 9, 8, 3, 2, 1, 0].sort()
[ 0, 1, 10, 2, 3, 8, 9 ]

[10, 9, 8, 3, 2, 1, 0].sort((a,b) => a - b)

>[1,2,3,4].map(foo => {bar: foo * 10})
[undefined, undefined, undefined, undefined]
>[1,2,3,4].map(foo => {bar: foo * 10, baz: foo})
Syntax error!

This is correct. Because the curly brackets are not recognized as object but as function scope. If the curly brackets would be surrounded with normal brackets, it would work

> 3 > 2 > 1
false

> 3 > 2 >= 1
true

Those two are correct. You'd get the same result in c++. In 3 > 2 > 1 we have 2 operators, so firstly we calculate 3 > 2 and since it returns true, next operation is true > 1. Since when comparing bool and int, we convert bool to int, we get 1 > 1, which is false.