JavaScript logical operator ' | | ' and "&&"

First, to say that | | (logical OR), which, literally, returns false only when both the front and back are false, otherwise it returns true.

Alert (true| | FALSE);    True
Alert (false| | true);    True
Alert (true| | true);        True
Alert (false| | FALSE);    False

But, in the deep sense, there is another world, try the following code

Alert (0| | 1);

Obviously, we know that the previous 0 means false, and the next 1 means true, then the result above should be true, and the result of the fact returned is 1. Then look at the following code:

Alert (2| | 1);

We know that the previous 2 is true, and the back 1 is also true, so what is the return result? The test result is 2, continue to look:

Alert (' A ' | | 1);

Again, the front ' a ' is true, the back 1 is also true; the test result is ' a ', below

Alert (' | | | 1);

From the top, we know that the front "is false, the back 1 is true, and the return result is 1." Look at the bottom again.

Alert (' A ' | | 0);

The front ' a ' is true, and the back 0 is false, and the result is ' a ', continue below

Alert (' A ' | | ' B ');

The front ' a ' is true, the back ' B ' is false and the return result is ' a ', we continue below

Alert (' | | | 0);

The front "is false, and the back 0 is also false, and the result is 0

Alert (0| | ");

The previous 0 is false, the back "is false, and the return result is '

This means

1, as long as "| |" False in front, regardless of "| |" Followed by true or FALSE, return "| |" The value that follows.

2, as long as "| |" Preceded by true, regardless of "| |" Followed by true or FALSE, return "| |" The preceding value.

----------------------------------------------------------------------------------------------------------

Second, the following say && (logic and), literally, only true before and after the time to return true, otherwise return false.

alert (true&&false);    False
alert (true&&true);    True
alert (false&&false);    False
alert (false&&true);    False

Then, based on the above experience, we look at the "&&" number, not just the case of Boolean type.

Alert (' &&1 ');

The knot is returned ', ' && ' front ' is false, followed by 1 is true.

Alert (' &&0 ');

The knot is returned ', ' && ' front ' is false, followed by 0 and false.

Alert (' a ' &&1);

The knot is returned 1, "&&" before "a" is true, followed by 1 is also true.

Alert (' a ' &&0);

The knot is returned 0, "&&" before "a" is true, followed by 0 is false.

Alert (' A ' && ');

The knot is returned ', ' && ' preceded ' A is true, followed by ' is false.

Alert (0&& ' a ');

The knot is returned 0, "&&" before ' 0 is false, followed by ' a ' is true.

Alert (0&& ');

The knot is returned 0, "&&" before "0 is false, followed by" is also false.

This means that

1, as long as "&&" is false, whether "&&" followed by true or false, the result will be "&&" the preceding value;

2, as long as "&&" is true, whether "&&" followed by true or false, the result will be returned to "&&" the value after;

Let's summarize:

1, as long as "| |" False before, regardless of ' | | ' Followed by true or FALSE, the result returns "| |" The value that follows.

2, as long as "| |" Preceded by true, regardless of "| |" Followed by true or FALSE, the result returns "| |" The preceding value.

3, as long as "&&" is false, whether "&&" followed by true or false, the result will be "&&" the preceding value;

4, as long as "&&" is true, whether "&&" followed by true or false, the result will be returned to "&&" the value after;

From the last two Tests, the logical operator, "| |" and "&&" are to follow the short-circuit principle, as long as the symbol before the true and false, can determine the return value.

It should be stated that the priority of "&&" is higher than "| |" , the following tests:

Alert (1| | ' A ' &&2);

The return result is 1.

Based on the principle of absurdity, we assume that "| |" The priority level is not less than "&&" (Here only so "no less" is to prove the same level of the same situation).

According to the conclusions we have drawn above (1), (1| | ' A ') will return the previous value 1, (1&&2) according to the conclusion (4) should return the following value 2. This is obviously not true, so the priority of "&&" is higher than "| |" Of

JavaScript logical operator ' | | ' and "&&"