Quelle est la signification des opérateurs logiques javascript

En JavaScript, les opérateurs logiques sont des symboles spéciaux qui relient les instructions en instructions plus complexes. Les opérateurs logiques peuvent être utilisés pour représenter des opérations logiques telles que « négation », « ou » et « et » ; , "&&" et "||" trois opérateurs logiques.

L'environnement d'exploitation de ce tutoriel : système Windows 10, JavaScript version 1.8.5, ordinateur Dell G3.

Quelle est la signification des opérateurs logiques javascript ?

Les opérateurs logiques sont utilisés pour exprimer des idées telles que « et », « ou » et « sauf si » dans la communication quotidienne.

Opérateurs logiques : dans la logique formelle, les opérateurs logiques ou connecteurs logiques connectent les instructions en instructions plus complexes.

Par exemple, supposons qu'il y ait deux propositions logiques, à savoir « Il pleut » et « Je suis dans la maison ». On peut les transformer en propositions complexes : « Il a plu et j'étais dans la maison » ou « Il n'a pas plu » ou « S'il pleuvait, j'étais dans la maison ». Une nouvelle déclaration ou proposition composée de deux déclarations est appelée une déclaration composée ou une proposition composée.

La raison pour laquelle « ET » et « OU » ont deux formes d'opérateurs différentes est que leurs priorités de fonctionnement sont différentes. Les opérateurs sont utilisés pour effectuer des opérations sur le code de programme et effectueront des opérations sur plusieurs éléments d'opérande.

Opérateurs logiques en JavaScript

Tout d'abord, parlons des règles de conversion d'autres types de données en types booléens :

null, indéfini, 0, NaN, les chaînes vides sont converties en faux et les autres sont converties en vrai.

Il existe trois opérateurs logiques en JavaScript :

1.

Convertissez d'abord les données en une valeur booléenne, puis annulez-les. Le résultat est vrai ou faux

<script type="text/javascript">
var a = [1,2,3];
var b = "hello";
var obj = new Object();
var d;
console.log(!"");
console.log(!d);
console.log(!a);
console.log(!b);
console.log(!obj);
</script>

2. ET logique &&

Le ET logique en js n'est pas le même que dans les autres langages. L'opérande est vrai (ou peut être converti en vrai), le résultat du calcul est le deuxième opérande. Si le premier opérande est faux, le résultat est faux (calcul de court-circuit pour certaines valeurs spéciales, les règles ci-dessus ne sont pas respectées).

<script type="text/javascript">
var a = [1,2,3];
var b = "hello";
var obj = new Object();
var d;
console.log(true && 10);//第一个操作数是true，结果是第二个操作，也就是10
console.log(false && b);//第一个操作数是false，结果flase
console.log(100 && false);//第一个操作数是100，结果flase
console.log(undefined && false);//第一个操作数是undefined，结果undefined
console.log(NaN && false);//第一个操作数是NaN，结果NaN
console.log(null && false);//第一个操作数是null，结果null
console.log(&#39;&#39; && false);//第一个操作数是空串，结果空串
console.log(0 && 100);//结果是0
console.log(5 && 100);//100
console.log(a && b);//hello
console.log(obj && 200);//200
</script>

3. OU logique ||

Si le premier opérande n'est pas faux, le résultat est le premier opérande, sinon le résultat est le deuxième opérande. Si le premier opérande peut être converti en vrai, le résultat est le premier opérande

<script type="text/javascript">
var a = [1,2,3];
var b = "hello";
var obj = new Object();
var d;
console.log(true || 10);//第一个操作数是true，结果是第一个操作，也就是true
console.log(false || b);//第一个操作数是false，结果是第二个操作数b
console.log(100 || false);//第一个操作数是100，结果100
console.log(undefined || 9);//第一个操作数是undefined转false，结果9
console.log(NaN || false);//第一个操作数是NaN转false，结果第二个操作数
console.log(null || a);//第一个操作数是null转false，结果a
console.log(&#39;&#39; || false);//第一个操作数是空串转false，结果第二操作数
console.log(0 || 100);//结果是100
console.log(5 || 100);//5
console.log(a || b);//a
console.log(obj || 200);//obj
</script>

Recommandations associées : Tutoriel d'apprentissage 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!