|| et && utilisation en JavaScript (explication détaillée)

&& et || sont particulièrement largement utilisés dans le code source de JQuery. J'ai trouvé quelques exemples sur Internet comme référence et étudié leur utilisation :

&&

function a(){
    alert("a");
    return true;
}
function b(){
    alert("b");
    return true;
}
var c=a()&&b();
alert(c);

a() && b() : Si true est renvoyé après l'exécution de a(), alors b() est exécuté et la valeur de b est renvoyée si false est renvoyée après l'exécution de a() ; , l'expression entière La formule renvoie la valeur de a(), b() n'est pas exécutée

||

function a(){
    alert("a");
    return true;
}
function b(){
    alert("b");
    return false;
}
var c=a()||b();
alert(c);

; a() || b( ) : Si true est renvoyé après l'exécution de a(), l'expression entière renvoie la valeur de a() et b() n'est pas exécuté si false est renvoyé après l'exécution de a(), b( ; ) est exécuté et la valeur de b() est renvoyée

&& a une priorité plus élevée que ||

alert((1 && 3 || 0 ) && 4); //Résultat 4 ①

alerte(1 && 3 || 0 && 4); //Résultat 3 ②
alerte(0 && 3 || 1 && 4); //Résultat 4 ③

Analyse :

Instruction ① : 1&&3 renvoie 3 => 3 || 0 renvoie 3 => 3&&4 renvoie 4
Instruction ② : exécutez d'abord 1&&3 et retournez 3, puis exécutez 0&&4 et retournez 0, et enfin comparez les résultats de l'exécution avec 3||0 et retournez 3
Instruction ③ : exécutez d'abord 0&&3 et retournez 0, puis exécutez 1&&4 et retournez 4. Enfin, comparez le résultat de l'exécution avec 0||4 et retournez 4.

Remarque : tous les entiers non nuls sont vrais, indéfinis, nuls et la chaîne vide "" est fausse.

En javascript, && peut non seulement être utilisé pour le type booléen, ni renvoyer uniquement des résultats de type booléen.
l Si le premier opérande est de type booléen et que la valeur est fausse, renvoyez directement false.
l Si le premier opérande est de type booléen et que la valeur est vraie, et que l'autre opérande est de type objet, alors cet objet sera renvoyé.
l Si les deux opérandes sont de type objet, alors le deuxième objet est renvoyé.
l Si un opérande est nul, alors null est renvoyé.
l Si un opérande est NaN, renvoie NaN.
l Si un opérande n'est pas défini, alors undéfini est renvoyé.

alert(false && alice); // false 
alert(true && alice); // alice 
alert(alice && smith); // smith 
alert(smith && alice); // alice 
alert(null && alice); // null 
alert(NaN && alice); // NaN 
alert(undefined && alice); // undefined 
alert(alice && undefined); // undefined

Pour ||, il n'est pas non plus utilisé uniquement pour le type booléen, ni ne renvoie uniquement le type booléen de résultat.

En fait, null, undefined et NaN seront traités comme faux. Et l'objet est traité comme vrai.

l Si le premier opérande est de type booléen et que la valeur est vraie, alors retournez vrai directement.
l Si le premier opérande est de type booléen et que la valeur est fausse et que le deuxième opérande est objet, alors l'objet objet est renvoyé.
l Si les deux opérandes sont de type objet, renvoie le premier objet.
l Si les deux opérandes sont nuls, alors null est renvoyé.
l Si les deux opérandes sont NaN, renvoie NaN.
l Si les deux opérandes ne sont pas définis, alors undéfini est renvoyé.

alert(false || alice);     // alice
alert(true || alice);     // true
alert(alice || smith);     // alice
alert(smith || alice);     // smith
alert(null || alice);     // alice
alert(alice || null);     // alice
alert(null || null);     // null
alert(NaN || alice);      // alice
alert(alice || NaN);      // alice
alert(NaN || NaN);       // NaN
alert(undefined || alice);   // alice
alert(alice || undefined);   // alice
alert(undefined || undefined); // undefined

Pas besoin de faire si compliqué, je vous recommande de lire cette partie de l'explication

a && b : convertissez a, b en type booléen, puis effectuez un ET logique, renvoyez b si vrai, renvoyez a si faux
a || b : convertissez a, b en type booléen, puis effectuez une opération logique. OU, vrai renvoie a, faux renvoie b

Règles de conversion :
L'objet est vrai
Un nombre différent de zéro est vrai
Une chaîne non vide est vraie
Les autres sont faux

Ce qui précède représente l'intégralité du contenu de ce chapitre. Pour plus de didacticiels connexes, veuillez visiter le Tutoriel vidéo JavaScript !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!