Differences in assignment between consecutive && and || in Javascript expressions_javascript skills

The code is as follows:

Copy code The code is as follows:

function write(msg){
for(var i = 0; i < arguments.length; i ){
document.write(arguments[i] '
');
}
}
/ /about '&&'
test1 = 1 && 2 && 3 && 4;
test2 = '0' && 2 && 3 && 4;
test3 = 1 && 2 && 0 && 4;
test4 = 2 && 'i' && 'love' && 3 && 'you';
test5 = 'i' && 'hate' && 1 && 0 && 'you';
test6 = 1 && false && 'ihateyou' && '2';
test7 = 2 && true && 'ihatehateyou' && '23';
test8 = 4 && true && 'undefined' && 'true' && '1';
test9 = 4 && true && undefined && 'true' && '1';
test10 = 4 && true && 'null' && 'true' && '1';
test11 = 4 && true && null && 'true' && '1 ';
write(test1, test2, test3, test4, test5, test6, test7, test8, test9, test10, test11);
write('-------------- --------------------------------');
//About '||'
_test1 = 1 || 2 || 3 || 4;
_test2 = 0 || 2 || 3 || 4;
_test3 = 0 || '0' || 8 || 4;
_test4 = 2 || 'i' || 'love' || 0 || 'you';
_test5 = 0 || 'hate' || 1 || 0 || 'you';
_test6 = false | | 0 || 'ihateyou' || '2';
_test7 = false || true || 'ihateyou' || '23';
_test8 = 0 || 0 || 'undefined' || ' true' || '1';
_test9 = 0 || 0|| undefined || 'true' || '1';
_test10 = 0 || false || 'null' || 'true' || '1';
_test11 = 0 || 0 || null || 'true' || '1';
write(_test1, _test2, _test3, _test4, _test5, _test6, _test7, _test8, _test9, _test10, _test11);

Look at the output and you will understand:

The output of '&&' is:

Copy code The code is as follows:

4
4
0
you
0
false
23
1
undefined
1
null

The number of each row corresponds to each test above.

The output result of '||' is:

Copy code The code is as follows:

1
2
0
2
hate
ihateyou
true
undefined
true
null
true

If you compare it carefully, it will become clearer:

If there are no 0, false, undefined, null in the expressions of multiple consecutive &&, it will get the last " subexpression", otherwise 0, false, undefined, and null in the expression will be returned.

Multiple consecutive || expressions will take the value of the first "subexpression". If it is one of 0, false, undefined, null, the value of the next "subexpression" will be taken. "value, and so on, until a "subexpression" that is not 0, false, undefined, null is found, and it is used as the value of the entire expression.

Supplement:

The above does not seem to consider a situation, that is, what should I do if there is a subexpression of ''? In fact, we can use another way of expressing it to describe how && and || work:

For (...) && (...) && (...) ...

Traverse each subexpression from left to right, and cast each subexpression to Boolean. If Boolean (subexpression) is false, the value of the entire expression is the value of this subexpression. (0 or false or undefined or null or ''), the following subexpressions are no longer evaluated; if all Boolean (subexpressions) are true, the value of the entire expression is the value of the last subexpression .

For (...) || (...) || (...) ...

Traverse each sub-expression from left to right and convert each sub-expression The expression is forced to Boolean. If Boolean (subexpression) is true, the value of the entire expression is the value of this subexpression, and the following subexpressions will no longer be "ignored"; if Boolean (subexpression) expression) is false, then determine the Boolean condition of the next subexpression until a Boolean (subexpression) is found to be true; if all Boolean (subexpressions) are false, return the last subexpression The value (0 or false or undefined or null or '').

Note here:

Boolean(false) != Boolean('false'), the former is false and the latter is true.

Boolean(undefined) != Boolean('undefined'), the former is false and the latter is true .

Boolean(null) != Boolean('null'), the former is false and the latter is true.

Boolean(0) != Boolean('0'), the former is false and the latter is true.

Boolean('') == false