Opérateurs logiques JavaScript || et &&

Tout d'abord, parlons de || (OU logique). Littéralement, il renvoie false uniquement lorsque les deux côtés sont false ; sinon, il renvoie true.

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

Cependant, dans un sens plus profond, il y a une autre histoire. Essayez le code suivant :

alert(0||1);

Évidemment, nous savons que le 0 précédent signifie false, et le 1 suivant signifie true, donc le résultat ci-dessus devrait être true, mais le résultat réellement renvoyé est 1. Regardez le code ci-dessous :

alert(2||1);

Nous savons que le 2 précédent est true, et le 1 suivant est aussi true. Alors quel est le résultat renvoyé ? Le résultat du test est 2. Continuez :

alert('a'||1);

De même, le 'a' précédent est true, et le 1 suivant est aussi true ; le résultat du test est 'a'. Ci-dessous :

alert(''||1);

D'après ce qui précède, nous savons que le '' précédent est faux, et que le 1 suivant est vrai, et que le résultat renvoyé est 1. Regardez ci-dessous :

alert('a'||0);

Le 'a' précédent est vrai, tandis que le 0 suivant est faux, donc le résultat renvoyé est 'a'. Continuez ci-dessous :

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

Le 'a' précédent est vrai, et le 'b' suivant est faux, donc le résultat renvoyé est 'a'. Nous continuons ci-dessous :

alert(''||0);

Le '' précédent est faux, et le 0 suivant est aussi faux, donc le résultat renvoyé est 0.

alert(0||'');

Le 0 précédent est faux, et le '' suivant est faux, donc le résultat renvoyé est ''.

Cela signifie :

1. Tant que la valeur avant || est fausse, peu importe que la valeur après || soit vraie ou fausse, elle renvoie la valeur après ||.
2. Tant que la valeur avant || est vraie, peu importe que la valeur après || soit vraie ou fausse, elle renvoie la valeur avant ||.

Deuxièmement, parlons de && (ET logique). Littéralement, il renvoie vrai uniquement lorsque les deux côtés sont vrais ; sinon, il renvoie faux.

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

Ensuite, d'après l'expérience ci-dessus, examinons les cas où les valeurs avant et après && ne sont pas uniquement de type booléen.

alert(''&&1);

Le résultat renvoie ''. La valeur avant && est '' (fausse), et la valeur après est 1 (vraie).

alert(''&&0);

Le résultat renvoie ''. La valeur avant && est '' (fausse), et la valeur après est 0 (également fausse).

alert('a'&&1);

Le résultat renvoie 1. La valeur avant && est 'a' (vraie), et la valeur après est 1 (également vraie).

alert('a'&&0);

Le résultat renvoie 0. La valeur avant && est 'a' (vrai), et la valeur après est 0 (faux).

alert('a'&&'');

Le résultat renvoie ''. La valeur avant && est 'a' (vrai), et la valeur après est '' (faux).

alert(0&&'a');

Le résultat renvoie 0. La valeur avant && est 0 (faux), et la valeur après est 'a' (vrai).

alert(0&&'');

Le résultat renvoie 0. La valeur avant && est 0 (faux), et la valeur après est '' (également faux).

Cela signifie :

1. Tant que la valeur avant && est fausse, que la valeur après && soit vraie ou fausse, le résultat renverra la valeur avant &&.
2. Tant que la valeur avant && est vraie, que la valeur après && soit vraie ou fausse, le résultat renverra la valeur après &&.

Résumons :

1. Tant que la valeur avant || est fausse, que la valeur après || soit vraie ou fausse, le résultat renvoie la valeur après ||.
2. Tant que la valeur avant || est vraie, que la valeur après || soit vraie ou fausse, le résultat renvoie la valeur avant ||.
3. Tant que la valeur avant && est fausse, que la valeur après && soit vraie ou fausse, le résultat renverra la valeur avant &&.
4. Tant que la valeur avant && est vraie, que la valeur après && soit vraie ou fausse, le résultat renverra la valeur après &&.

D'après les deux tests ci-dessus, les opérateurs logiques || et && suivent tous deux le principe de court-circuit. Tant que la valeur de vérité de la valeur avant le symbole est déterminée, la valeur de retour peut être déterminée.

Il convient de noter que && a une priorité plus élevée que ||. Test ci-dessous :

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

Le résultat renvoyé est 1.

Selon le principe de preuve par l'absurde, nous supposons que la priorité de || n'est pas inférieure à && (la raison d'utiliser « non inférieure » ici est de prouver aussi le cas où elles ont la même priorité).

D'après la conclusion (1) que nous avons dérivée ci-dessus, (1 || 'a') renverra la valeur précédente 1 ; d'après la conclusion (4), (1 && 2) devrait renvoyer la valeur suivante 2. Ceci est manifestement incorrect. De cela, nous pouvons voir que && a une priorité plus élevée que ||.

URL source : http://www.cnblogs.com/pigtail/archive/2012/03/09/2387486.html