javascript - Why is typeof's result different than the evaluated result of the expression passed in?

Question

If two Objects added together equal NaN(not a number), which is technically of type number, then why does getting the type of two Objects added together result in "string"?

I will express this via the REPL:
> {} + {}
> NaN
ok. two objects added together creates NaN

> typeof(NaN)
> "number"
ok. we know that NaN's type is "number"

> typeof({} + {})
> "string"
wait. shouldn't this have been "number" also?

I'm aware that javascript has a less then desireable type system, but I'm confused as to what's happening here. Is the type being converted from number to string for some reason? Is number even a part of the type converting that goes on here? Or am I just using typeof wrong?

Answer 1

{} + {} is an empty block ({}) followed by a type conversion from object to number (+{}). It basically reads as

{} // empty block (a statement)
;  // empty statement (just for clarity)
+{}; // expression statement (unary plus, object literal -> conversion to number)

However if you use typeof ({} + {}), then {} + {} will be evaluated as expression in which case both {} can only be object literals and the + is the concatenation operator.

You can also just use the grouping operator to force the construct to be evaluated as expression:

({} + {}) // expression statement (string concatenation with two objects)

---

See also Why {} + {} is NaN only on the client side? Why not in Node.js? and other questions related to [javascript] "{} + {}".