Javascript: check your intuition

 "3" -+-+-+ "1" + "1" / "3" * "6" + "2" == "42" 

As we already know from the last post, the “+” operator performs either string concatenation, addition, or coercion to a number. Those.

 “3” + 2 == “32” 

not 5, as one might think.
')
In addition, you can throw a unary “+” or “-” operator on an expression to change its sign and make things more beautiful and readable.

With all this in mind:

 + “1” === 1 -+ “1” === -1 +-+ “1” === -1 … -+-+-+ === -1 "3" -+-+-+ "1" === 2 //    

Then we recall the priority of operations: / * +

 “1”/”3” === 0.3333… “1” / ”3” * ”6” === 2 2 + 2 === 4 4 + “2” === “42” 

 Math.max(3, 0); // 3 

It's simple.

 Math.max(3, {}); // NaN 

try to execute toNumber for {}:
let's execute valueOf and check whether it is primitive - no, then
execute toString and get "[object Object]" ;
execute the resulting string toNumber and get NaN ;
in the case of obtaining NaN, Math.max () always returns NaN .

 Math.max(3, []); // 3 

try to execute toNumber for []:
let's execute valueOf and check whether it is primitive - no, then
run toString and get "";
execute the resulting string toNumber and get 0;
3> 0

 Math.max(-1, [1]); // 1 

Try to execute toNumber for [1]:
let's execute valueOf and check whether it is primitive - no, then
execute toString and get "1";
execute the resulting string toNumber and get 1;
-1 <1

 Math.max(-1, [1, 4]); // NaN 

try to execute toNumber for [1,4]:
let's execute valueOf and check whether it is primitive - no, then
execute toString and get "1,4";
execute the resulting string toNumber and get NaN ;
in the case of obtaining NaN, Math.max () always returns NaN .

 Math.max(3, true); // 3 

try to execute toNumber for true :
let's execute valueOf and check whether it is primitive - yes, then

 toNumber(true) === 1 

3> 1

 Math.max(3, 'foo'); // NaN 

for 'foo' toNumber returns NaN .
In the case of getting NaN, Math.max () always returns NaN .

 Math.max(-1, null); // 0 

 toNumber(null) === 0 -1 < 0 

 Math.max(-1, undefined); // NaN 

 toNumber(undefined) === NaN 

in the case of obtaining NaN, Math.max () always returns NaN .

 [,,,].join() // ",," [,,,undefined].join() // ",,," 

Here I can only refer to Flanagan. 7.1:
“If an array literal contains several consecutive commas with no values ​​between them, a sparse array is created. The elements corresponding to these missing values ​​are missing in the array, but returning to them returns the value undefined. ”
"The syntax of array literals allows you to insert an optional trailing comma."
Why is this done I do not understand. In comments to the last post it was presented as a feature. In my opinion, this is still a browser crutch from errors in the code.

 Array(20).map(function(elem) { return 'a'; }); // Array of undefined x 20 

Calling the Array constructor with one argument creates not an array of 20 elements, but an array whose length is 20. And the map method first creates an empty array whose length equals the length of the passed array, and then calls a callback for each element of the passed array. In our case, the array has no elements and the method returns an empty array of the same length as the original one.

 isFinite(42); // true isFinite(1/0); // false isFinite(0/0); // NaN is not finite -> false isFinite('42'); // true isFinite('hi'); // false isFinite(); // false isFinite(undefined); // false isFinite(null); // true 

isFinite leads the argument to a number, and if NaN, + Infinity or -Infinity is obtained , it returns false . In all other cases, true .
ToNumber from 'hi' returns NaN , undefined returns NaN , and null returns 0.

 'true' == true //false 

The equality operator will sequentially lead to numbers, first true, then 'true'. It turns out NaN == 1, which is obviously false.

 null == false // false !null // true 

With null reduction to bool, everything is clear. We will understand the comparison. the combination of null and bool does not fall under any of the comparison / coercion options in clause 11.9.3 of the specification and therefore the comparison returns false .

 /^[az]{1,10}$/.test(null); //true /^[az]{1,10}$/.test(undefined); //true 

Null and undefined are cast to the string as is: “null” and “undefined” - and such strings satisfy the regular expression. And NaN , by the way, will also become "NaN".

  0 === -0 //true 1/0 === 1/-0 //false 

Zero is equal to negative zero, but when dividing with a sign, the sign is taken into account and it turns out

 Infinity === -Infinity 

 n = 1 /1*"\/\//.test(n + '"//') //NaN n = 1; /1*"\/\//.test(n + '"//'); //true 

Slash can be used in three cases: regular expression, division, and comment. Here, at first glance, we see only the regular expression. But, in fact, without a semicolon, the first slash performs a division. Thus, the first division is performed, and then the result is multiplied by the string. The remaining tail is just a comment. The string by which we multiply to the number is not given and it turns out NaN .