Сначала поговорим про || (логическое ИЛИ). Буквально он возвращает false только когда обе стороны false; в противном случае он возвращает true.

alert(true||false);       // true
alert(false||true);       // true
alert(true||true);        // true
alert(false||false);      // false

Однако в более глубоком смысле всё иначе. Попробуйте следующий код:

alert(0||1);

Очевидно, мы знаем, что предшествующее значение 0 означает false, а последующее значение 1 означает true, поэтому приведённый выше результат должен быть true, но фактически возвращается 1. Посмотрите код ниже:

alert(2||1);

Мы знаем, что предшествующее значение 2 истинно, а последующее значение 1 тоже истинно. Так каков возвращаемый результат? Результат теста — 2. Продолжаем:

alert('a'||1);

Аналогично, предшествующее значение 'a' истинно, а последующее значение 1 тоже истинно; результат теста — 'a'. Ниже:

alert(''||1);

Из вышесказанного мы знаем, что предшествующее '' является ложным, а следующее 1 — истинным, и возвращаемый результат равен 1. Смотрите ниже:

alert('a'||0);

Предшествующее 'a' истинно, тогда как следующее 0 ложно, поэтому возвращаемый результат — 'a'. Продолжаем ниже:

alert('a'||'b');

Предшествующее 'a' истинно, а следующее 'b' ложно, поэтому возвращаемый результат — 'a'. Продолжаем ниже:

alert(''||0);

Предшествующее '' ложно, и следующее 0 также ложно, поэтому возвращаемый результат равен 0.

alert(0||'');

Предшествующее значение 0 ложно, а следующее значение '' ложно, поэтому возвращаемый результат — ''.

Это означает:

• 1. Если значение перед || ложно, независимо от того, истинно или ложно значение после ||, возвращается значение после ||.
• 2. Если значение перед || истинно, независимо от того, истинно или ложно значение после ||, возвращается значение перед ||.

Во-вторых, поговорим о && (логическое И). Буквально, он возвращает истину только тогда, когда обе стороны истинны; в противном случае он возвращает ложь.

alert(true&&false);      // false
alert(true&&true);       // true
alert(false&&false);     // false
alert(false&&true);      // false

Затем, основываясь на вышеописанном опыте, рассмотрим случаи, когда значения перед и после && не являются только булевыми типами.

alert(''&&1);

Возвращается ''. Значение перед && — '' (ложно), а значение после — 1 (истинно).

alert(''&&0);

Возвращается ''. Значение перед && — '' (ложно), а значение после — 0 (также ложно).

alert('a'&&1);

Возвращается 1. Значение перед && — 'a' (истинно), а значение после — 1 (также истинно).

alert('a'&&0);

Результат возвращает 0. Значение перед && — 'a' (true), а значение после — 0 (false).

alert('a'&&'');

Результат возвращает ''. Значение перед && — 'a' (true), а значение после — '' (false).

alert(0&&'a');

Результат возвращает 0. Значение перед && — 0 (false), а значение после — 'a' (true).

alert(0&&'');

Результат возвращает 0. Значение перед && — 0 (false), а значение после — '' (тоже false).

Это означает:

• 1. Если значение перед && равно false, независимо от того, равно ли значение после && true или false, результат вернёт значение перед &&.
• 2. Если значение перед && равно true, независимо от того, равно ли значение после && true или false, результат вернёт значение после &&.

Подведём итог:

• 1. Если значение перед || равно false, независимо от того, равно ли значение после || true или false, результат возвращает значение после ||.
• 2. Если значение перед || равно true, независимо от того, равно ли значение после || true или false, результат возвращает значение перед ||.
• 3. Если значение перед && равно false, независимо от того, равно ли значение после && true или false, результат вернёт значение перед &&.
• 4. Если значение перед && равно true, независимо от того, равно ли значение после && true или false, результат вернёт значение после &&.

Из двух приведённых выше тестов следует, что логические операторы || и && оба подчиняются принципу короткого замыкания. Если истинность значения перед символом определена, можно определить возвращаемое значение.

Следует отметить, что && имеет более высокий приоритет, чем ||. Тест ниже:

alert(1||'a'&&2);

Возвращаемый результат равен 1.

Согласно принципу доказательства от противного, предположим, что приоритет || не ниже && (причина использования "не ниже" здесь в том, чтобы также доказать случай, когда они имеют одинаковый приоритет).

Согласно выводу (1), полученному выше, (1 || 'a') вернёт предыдущее значение 1; согласно выводу (4), (1 && 2) должно вернуть следующее значение 2. Это, очевидно, неверно. Из этого видно, что && имеет более высокий приоритет, чем ||.

Источник URL: http://www.cnblogs.com/pigtail/archive/2012/03/09/2387486.html