Primero, hablemos de || (OR lógico). Literalmente, solo cuando ambos lados son false se devuelve false; de lo contrario, se devuelve true.

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

Pero, en un sentido más profundo, hay otro panorama. Probemos el siguiente código:

alert(0||1);

Obviamente, sabemos que el 0 anterior significa false, y el 1 posterior significa true, por lo que el resultado anterior debería ser true, pero el resultado real devuelto es 1. Veamos el siguiente código:

alert(2||1);

Sabemos que el 2 anterior es true y el 1 posterior también es true. ¿Cuál es el resultado devuelto? El resultado de la prueba es 2. Continuemos:

alert('a'||1);

De igual manera, el 'a' anterior es true y el 1 posterior también es true; el resultado de la prueba es 'a'. A continuación:

alert(''||1);

Por lo anterior, sabemos que el '' anterior es false y el 1 posterior es true, y el resultado devuelto es 1. Veamos lo siguiente:

alert('a'||0);

El 'a' anterior es true, y el 0 posterior es false; el resultado devuelto es 'a'. Continuemos:

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

El 'a' anterior es true, el 'b' posterior es false; el resultado devuelto es 'a'. Seguimos con lo siguiente:

alert(''||0);

El '' anterior es false, y el 0 posterior también es false; el resultado devuelto es 0.

alert(0||'');

El 0 anterior es false, el '' posterior es false; el resultado devuelto es ''.

Esto significa:

• 1. Siempre que lo anterior a || sea false, sin importar si lo posterior a || es true o false, se devuelve el valor posterior a ||.
• 2. Siempre que lo anterior a || sea true, sin importar si lo posterior a || es true o false, se devuelve el valor anterior a ||.

Segundo, hablemos de && (AND lógico). Literalmente, solo cuando ambos lados son true se devuelve true; de lo contrario, se devuelve false.

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

Luego, según la experiencia anterior, veamos el caso en que lo anterior y posterior a && no son solo de tipo booleano.

alert(''&&1);

El resultado devuelve ''. Lo anterior a && es '' que es false, y lo posterior es 1 que es true.

alert(''&&0);

El resultado devuelve ''. Lo anterior a && es '' que es false, y lo posterior es 0 que también es false.

alert('a'&&1);

El resultado devuelve 1. Lo anterior a && es 'a' que es true, y lo posterior es 1 que también es true.

alert('a'&&0);

El resultado devuelve 0. Lo anterior a && es 'a' que es true, y lo posterior es 0 que es false.

alert('a'&&'');

El resultado devuelve ''. Lo anterior a && es 'a' que es true, y lo posterior es '' que es false.

alert(0&&'a');

El resultado devuelve 0. Lo anterior a && es 0 que es false, y lo posterior es 'a' que es true.

alert(0&&'');

El resultado devuelve 0. Lo anterior a && es 0 que es false, y lo posterior es '' que también es false.

Esto significa

• 1. Siempre que lo anterior a && sea false, sin importar si lo posterior a && es true o false, el resultado devolverá el valor anterior a &&.
• 2. Siempre que lo anterior a && sea true, sin importar si lo posterior a && es true o false, el resultado devolverá el valor posterior a &&.

Resumamos:

• 1. Siempre que lo anterior a || sea false, sin importar si lo posterior a || es true o false, el resultado siempre devuelve el valor posterior a ||.
• 2. Siempre que lo anterior a || sea true, sin importar si lo posterior a || es true o false, el resultado siempre devuelve el valor anterior a ||.
• 3. Siempre que lo anterior a && sea false, sin importar si lo posterior a && es true o false, el resultado devolverá el valor anterior a &&.
• 4. Siempre que lo anterior a && sea true, sin importar si lo posterior a && es true o false, el resultado devolverá el valor posterior a &&.

De las dos pruebas anteriores se puede ver que los operadores lógicos || y && siguen el principio de cortocircuito; solo es necesario determinar si lo anterior al símbolo es verdadero o falso para determinar el valor de retorno.

Cabe señalar que la precedencia de && es mayor que la de ||. Prueba a continuación:

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

El resultado devuelto es 1.

Según el principio de reducción al absurdo, supongamos que la precedencia de || no es menor que la de && (aquí se usa "no menor que" para demostrar también el caso en que tienen el mismo nivel).

Según la conclusión (1) que obtuvimos arriba, (1 || 'a') devolverá el valor anterior 1; (1 && 2), según la conclusión (4), debería devolver el valor posterior 2. Esto evidentemente es incorrecto, por lo que se deduce que la precedencia de && es mayor que la de ||.

Dirección de origen: http://www.cnblogs.com/pigtail/archive/2012/03/09/2387486.html