Résumer les compétences d'utilisation des opérateurs booléens || et && dans les compétences JavaScript_javascript

Avez-vous déjà vu du code comme celui-ci : a=a||""; Peut-être que les débutants en JavaScript seront déroutés par cela. Aujourd'hui, je vais partager avec vous certaines de mes expériences.
En fait :

a=a||"defaultValue";

a=a||"defaultValue"; 
 

et :

if(!a){
a="defaultValue";
}
if(!a){ 
  a="defaultValue"; 
} 

et :

 
if(a==null||a==""||a==undefined){
a="defaultValue";
}

if(a==null||a==""||a==undefined){ 
  a="defaultValue"; 
} 

sont équivalents !
Afin de clarifier ce problème, nous devons d’abord comprendre un problème : que se passe-t-il lorsque le type de données en JavaScript est converti en type bool.

En JavaScript, les types de données peuvent être divisés en « vraies valeurs » et « fausses valeurs ». Comme son nom l'indique, lorsqu'une valeur vraie est convertie en bool, la valeur est vraie ; lorsqu'une valeur fausse est convertie en bool, la valeur est fausse. Le tableau suivant répertorie les valeurs de certains types de données courants lors de la conversion en booléen :

Dans l'expression if, JavaScript convertit d'abord l'expression conditionnelle en un type booléen. Si l'expression est vraie, la logique du if est exécutée, sinon elle est ignorée.

Il y a donc :

if(!a){
a="defaultValue";
}


if(!a){ 
  a="defaultValue"; 
} 

Examinons ensuite les deux expressions « && » et « || ».
JavaScript étant un langage faiblement typé, ces deux expressions en JavaScript peuvent être différentes de celles d'autres langages (comme Java).
En JavaScript, l'opérateur "&&" fonctionne comme suit :

Si la valeur de l'expression du côté gauche de && est vraie, la valeur de l'expression du côté droit est renvoyée ; sinon, la valeur de l'expression du côté gauche est renvoyée ;

Cela signifie :

var i=""&&"真值";//->i=""
i="真值"&&"其他真值";//->i="其他真值"
i="真值"&&"";//->i=""
var i=""&&"真值";//->i="" 
i="真值"&&"其他真值";//->i="其他真值" 
i="真值"&&"";//->i="" 

Les règles de fonctionnement de l'opérateur "||" sont les suivantes :

Si la valeur de l'expression du côté gauche de || est vraie, alors la valeur de l'expression du côté gauche est renvoyée ; sinon, la valeur de l'expression du côté droit est renvoyée ;

Cela signifie :

var i=""||"真值";//->i="真值"
i="真值"||"其他真值";//->i="真值"
i="真值"||"";//->i="真值"
var i=""||"真值";//->i="真值" 
i="真值"||"其他真值";//->i="真值" 
i="真值"||"";//->i="真值" 

Alors, vous pouvez comprendre :

a=a||"defaultValue";
a=a||"defaultValue"; 

La logique de

. Si a est une valeur fausse (égale à null, chaîne vide...), alors "defaultValue" est assigné à a sinon, la valeur de a est assignée à a lui-même.


Ci-dessous, nous utilisons ||, && pour simplifier le processus :

var parameter="";
function test(parameter){
//return 真值
return true;
}
//真值操作
function operate1(parameter){
return "真值操作";
}
//假值操作
function operate2(parameter){
return "假值操作";
}
var result=test(parameter)&&operate1(parameter);
result=test(parameter)||operate2(parameter);
//等价于
result=test(parameter)?operate1(parameter):operate2(parameter);
alert(result);//真值操作
//也等价于
if(test(parameter)){
result=operate1(parameter);
}else{
result=operate2(parameter);
}
alert(result)//真值操作

Autre exemple :

<script language="javascript" type="text/javascript"> 
  var a =1; 
  var b = 0; 
  var c = 3; 
  var d = a && b && c; 
  window.alert(d); 
</script> 

La valeur de sortie de d est 0. Si la valeur de d est modifiée en une valeur non égale à 0, alors d sera toujours 3

Donc && dans js renvoie la première valeur qui n'est pas vraie, qui est 0 (les objets peuvent également être utilisés), et si tous sont vrais, alors la dernière valeur renvoyée.
     

<script language="javascript" type="text/javascript"> 
  var a =0; 
  var b = 3; 
  var c = 5; 
  var d = a || b || c; 
  window.alert(d); 
</script> 

La valeur de sortie de d est 3. Si la valeur de b est modifiée en 0, alors d sera toujours 5. Si tous sont modifiés en 0, alors la valeur de d est 0.

Par conséquent, || dans js renvoie la première valeur qui n'est pas fausse, qui est 0 (les objets sont également acceptables), et si tous sont faux, la dernière valeur renvoyée.
Candidature :

Par exemple, si vous souhaitez simplement vérifier le format de l'e-mail, le format n'est correct que si « @ » et « . » existent en même temps, sinon un message d'erreur apparaîtra :

Lequel dois-je utiliser ? Décomposons-le :

if (form1.elements[3].value.indexOf("@",0)==-1 && form1.elements[3].value.indexOf(".",0)==-1){ alert("EMAIL地址输入错误!")}

Si les deux existent : les deux côtés de && sont faux. && renvoie la première valeur vraie, donc la condition de jugement if est fausse et l'instruction après le if n'est pas exécutée ! L'utilisateur ne sera pas invité.

Seulement au moins @ et. Il y a une erreur lorsque la condition if est vraie.

Lorsque les deux existent, la dernière valeur est renvoyée, ce qui est vrai. Si la condition de jugement est établie, l'instruction if est exécutée. Erreur utilisateur rapide.

Donc, utiliser && est évidemment faux !

devrait être remplacé par

if (form1.elements[3].value.indexOf("@",0)==-1 || form1.elements[3].value.indexOf(".",0)==-1){ alert("EMAIL地址输入错误!") }

Analyse :

Si les deux existent : tous sont faux, la valeur de retour est fausse, donc la condition if n'est pas établie, l'instruction n'est pas exécutée et aucune erreur n'est générée !

S'il n'en existe qu'une : renvoie la première valeur qui n'est pas fausse. Renvoie vrai pour indiquer une erreur !

Les deux n'existent pas : renvoie la première valeur qui n'est pas fausse, renvoie vrai et provoque une erreur !

Vous devriez donc utiliser ||