Compréhension complète des opérateurs javascript et des opérateurs logiques

Mots précédents
Logique L'opérateur effectue des opérations booléennes sur les opérandes et est souvent utilisé en conjonction avec des opérateurs relationnels. Les opérateurs logiques combinent plusieurs expressions relationnelles pour former une expression plus complexe. Les opérateurs logiques sont divisés en trois types : NON logique '!', ET logique '&&' et OU logique '||'. Cet article présentera ces trois opérateurs logiques
NON logique
. logique L'opérateur non- est représenté par un point d'exclamation (!) et peut être appliqué à n'importe quelle valeur dans ECMAScript. Cet opérateur renvoie une valeur booléenne quel que soit le type de données de la valeur. L'opérateur NON logique convertit d'abord son opérande en une valeur booléenne, puis l'annule
L'opérateur NON logique est converti en un type booléen type de conversion et une conversion Boolean() est identique, sauf que son résultat est inversé à la fin. Et si vous utilisez deux opérateurs NON logiques en même temps, cela simulera en fait le comportement de la fonction de transformation Boolean()

console.log(!!undefined);//false
console.log(!!null);//false
console.log(!!0);//false
console.log(!!-0);//false
console.log(!!NaN);//false
console.log(!!'');//false
console.log(!!false);//false

console.log(!!{});//true
console.log(!![]);//true

console.log(!!new Boolean(false));//true
console.log(!!false);//false
console.log(!!new Boolean(null));//true
console.log(!!null);//false

Opérateur NON logique est souvent utilisé pour contrôler les boucles

//Boolean 变量(bFound)用于记录检索是否成功。找到问题中的数据项时，bFound 将被设置为true，!bFound将等于false，意味着运行将跳出while循环
var bFound = false;
var i = 0;
while (!bFound) {
 if (aValue[i] == vSearchValues) {
  bFound = true;
 } else {
  i++;
 }
}

ET logique
Opération ET logique Le symbole est représenté par deux esperluettes (&&) et a deux opérandes. Ce n'est que lorsque les deux opérandes sont vrais que le résultat retournera vrai, sinon il retournera faux

<🎜. >Les opérations ET logiques peuvent être appliquées à n’importe quel type d’opérande, pas seulement aux valeurs booléennes. Si l'un des opérandes n'est pas une valeur booléenne, l'opération ET logique ne renvoie pas nécessairement une valeur booléenne

//逻辑与(&&)的真值表
第一个操作数    第二个操作数    结果
true       true        true
true       false       false
false       true        false
false       false       alse

L'opération ET logique est une opération de court-circuit Si le premier opérande peut déterminer le résultat, alors le. le deuxième opérande ne sera pas une évaluation d'opérande

Pour le ET logique, si le premier opérande est faux, quelle que soit la valeur du deuxième opérande, le résultat est faux, alors le premier opérande est renvoyé si Si le ; le premier opérande est vrai, alors le résultat vrai ou faux est le même que la valeur vraie ou fausse du deuxième opérande, puis le deuxième opérande est renvoyé

//除了false、undefined、null、+0、-0、NaN、''这7个假值，其余都是真值
console.log('t' && ''); //因为't'是真值，所以返回''
console.log('t' && 'f'); //因为't'是真值，所以返回'f'
console.log('t' && 1 + 2); //因为't'是真值，所以返回3
console.log('' && 'f'); //因为''是假值，所以返回''
console.log('' && ''); //因为''是假值，所以返回''

Les opérateurs logiques AND peuvent être utilisés dans plusieurs combinaisons pour renvoyer la valeur de la première expression dont la valeur booléenne est fausse

var i = 1;
var result = (true && i++);
console.log(result,i);//因为true是真值，所以执行i++，i是2，result是1

var i = 1;
var result = (false && i++);
console.log(result,i);//因为false是假值，所以不执行i++，i是1，result是false

console.log(true && 'foo' && '' && 4 && 'foo' && true);// ''

Relation

Priorité du niveau de l'opérateur
a une priorité plus élevée que le ET logique (&&) et le OU logique (||), donc des expressions similaires peuvent être écrites directement sans ajouter de parenthèses

Vous pouvez utiliser l'opérateur ET logique. pour remplacer la structure if

if(a+1==2 && b+2==3){
  //Todo  
}

L'opérateur logique ET est souvent utilisé dans la fonction de rappel

if (a == b) {
 doSomething();
}
// 等价于
(a == b) && doSomething();

//若没有给参数a传值，则a为默认的undefined，是假值，所以不执行a()，防止报错，如果给参数a传值，则执行函数a()
function fn(a){
  if(a){
    a();
  }
}
//等价于
function fn(a){
  a && a();
}

Logique OR

L'opérateur logique OR
est représenté par deux barres verticales (||) et comporte deux opérandes. Le résultat renvoie false uniquement lorsque les deux opérandes sont false , sinon renvoie true<. 🎜>
De même, l'opération logique OU peut également être appliquée à tout type d'opérande, pas seulement aux valeurs booléennes. Si l'un des opérandes n'est pas une valeur booléenne, l'opération OU logique ne renvoie pas nécessairement une valeur booléenne

//逻辑或(||)的真值表
第一个操作数    第二个操作数    结果
true       true       true
true       false       true
false       true       true
false       false       false

L'opération OU logique est également une opération de court-circuit Si le premier opérande peut déterminer le résultat, alors. le deuxième opérande ne sera pas Évaluation des opérandes

Pour le OU logique, si le premier opérande est vrai, alors quelle que soit la valeur du deuxième opérande, le résultat est vrai et le premier opérande est renvoyé ; Si le premier opérande est faux, alors la valeur vraie ou fausse du résultat est la même que la valeur vraie ou fausse du deuxième opérande, puis le deuxième opérande

console.log('t' || '');//因为't'是真值，所以返回"t"
console.log('t' || 'f');//因为't'是真值，所以返回"t"
console.log('' || 'f');//因为''是假值，所以返回"f"
console.log('' || '');//因为''是假值，所以返回""

est renvoyé

De même, l'opérateur logique OU peut également être utilisé dans plusieurs combinaisons pour renvoyer la valeur de la première expression dont la valeur booléenne est vraie

var i = 1;
var result = (true || i++);
console.log(result,i);//因为true是真值，所以不执行i++，result是true，i是1

var i = 1;
var result = (false || i++);
console.log(result,i);//因为false是假值，所以执行i++，i是2，result是1

L'opérateur logique L'opérateur OR est souvent utilisé. Définir la valeur par défaut de la variable

console.log(false || 0 || '' || 4 || 'foo' || true);// 4

//如果没有向参数p传入任何对象，则将该参数默认设置为空对象
function fn(p){
  p = p || {};
}

-->

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!