Comparaison de la priorité des opérateurs js et analyse des opérateurs logiques js

Cet article fournit une explication détaillée des différentes catégories d'opérateurs, puis décrit la priorité des opérateurs js. La priorité fait référence au niveau de priorité calculé de l'opérateur, qui sera présenté en détail ci-dessous.

Comment comparer les opérateurs en js ? Les opérateurs de comparaison dans le langage JavaScript sont principalement utilisés pour comparer si les valeurs de deux opérandes sont égales ou la taille. L'article a une valeur de référence et peut être récupéré en cas de besoin.

Présentation des opérateurs

JavaScript fournit un ensemble d'opérateurs pour manipuler les valeurs des données, également appelés opérateurs
Les opérateurs peuvent être utilisés en fonction de leurs différentes fonctions ou du nombre de variables manipulées. 🎜>

• Opérateurs arithmétiques

1. Si l'un ou les deux opérandes sont des types de chaîne, JavaScript les convertira automatiquement en valeurs numériques lors de l'exécution de calculs 2. Si l'un des opérandes est de type chaîne mais que les caractères ne sont pas des nombres, JavaScript convertira automatiquement la valeur numérique en résultat NaN

3. Tout opérande est un résultat NaN Les deux sont des valeurs booléennes NaN
4. ​​faux et vrai seront convertis en 0 et 1 pour le calcul

Opérateur d'addition
1 .Si les deux opérandes sont des valeurs numériques, l'addition le calcul sera effectué

2. Si le calcul d'addition de chaîne est effectué - Opérateur de concaténation de chaîne (chaîne de chaîne)

3. Si le type booléen est ajouté, calcul - Conversion du type booléen en valeur numérique puis calcul d'addition

Opérateur de soustraction
1. Avant l'opération de soustraction, convertissez les autres types en type numérique, puis effectuez le calcul

2. Si la chaîne est soustraite, convertissez le tapez une chaîne en une valeur numérique, puis effectuez une soustraction

3. Si le type booléen est soustrait, convertissez le type booléen en une valeur numérique, puis effectuez le calcul de soustraction

Opérateur restant
Opérateur restant

L'opérateur reste est utilisé pour calculer le reste après la division des deux opérandes

    console.log(100 % 3);//1
    console.log(8 % 4);//0

    console.log(100 % -3);//1
    console.log(8 % 4);//0

    console.log(-100 % 3);//-1
    console.log(-8 % 4);//0

    console.log(-100 % -3);//-1
    //与减法的情况保持一致
    console.log('卧龙学苑' % 2);//NaN

Le fait qu'un nombre positif ou un nombre négatif soit lié au fait que le premier opérande soit positif ou négatif (il). n'a rien à voir avec le second)

Opérateur d'incrémentation et opérateur de décrémentation

L'opérateur d'incrémentation automatique est utilisé pour ajouter 1 à la valeur entière successivement, qui est divisée en :

前置自增运算符 - ++变量名

a. Type de préposition : l'opérateur d'auto-incrémentation se situe avant l'opérande et ajoute 1 avant d'attribuer la valeur

后置自增运算符 - 变量名++

b. : l'opérateur d'auto-incrémentation est situé après l'opérande et se voit attribuer une valeur avant d'ajouter 1

L'opérateur d'auto-décrémentation est utilisé pour les valeurs entières -1 successivement et est divisé en :

a. Avant le type Set : l'opérateur de décrémentation est placé avant l'opérande, décrémentez-le de 1 puis attribuez la valeur

b Type de postposition : l'opérateur de décrémentation est placé avant l'opérande, attribuez la valeur puis décrémentez-la de. 1

• Niveau de priorité de l'opérateur
  
  
  Les opérateurs ont calculé le niveau de priorité
  1. Les opérateurs avec un niveau de priorité plus élevé sont calculés en premier
  2. Les opérateurs ont le même niveau, calcul de gauche à droite

  3. L'opérateur avec la priorité la plus élevée est "()"
4. Les expressions évaluées en premier sont entourées de "()"

    console.log(100 + 200 - 150 * 3);// -150
    console.log(100 + 200 % 3);// 102
    console.log(2 * 200 % 3);// 1

    var num = 10;
    console.log(5 + ++num);// 16

• Opérateurs de comparaison

一.大于与小于比较运算符

Les opérateurs de comparaison en langage JavaScript sont principalement utilisés pour comparer deux opérandes Que les valeurs soient égales ou leur taille

    console.log(10 > 11);//false
    console.log(11 > 10);//true
    console.log(10 >= 10);//true
    // 2.boolean类型 - 将boolean类型转换为number类型
    console.log(true > false);//true
    console.log(true > 0);//true
/*
    3.string类型 - a.英文; b.中文
    * 英文或中文 - 将文本转换成Unicode码 - 对应具有数字值
    * 英文单词 - 从左至右的一次比较字母 Unicode 码的大小
*/
    console.log(&#39;a&#39; < &#39;b&#39;);//true
    console.log(&#39;a&#39; > &#39;A&#39;);//true
    console.log(&#39;abc&#39; > &#39;cba&#39;);//false
    console.log(&#39;abc&#39; > &#39;acd&#39;);//false

    console.log(&#39;我&#39; > &#39;你&#39;);//true

二.相等与不等比较运算符

La différence entre l'opérateur de comparaison d'égalité
* et l'opérateur d'affectation
* l'opérateur d'affectation (=)
* Opérateur de comparaison d'égalité (==)
Opérateur de comparaison d'inégalité
*Le symbole est "!="

*Pas "<>"

    // 1.number类型
    console.log(10 == 10);// true
    console.log(10 == 11);// false
    // 2.boolean类型
    console.log(true == true);// true
    console.log(true == false);// false

    console.log(true == 1);// true

    // 3.string类型
    console.log('a' == 'a');// true
    console.log('a' == 'b');// false
    
    console.log('100' == 100);// true

Les opérateurs de comparaison d'égalité et d'inégalité comparent uniquement les opérandes. valeur de type

三.全等与不全等运算符 
全等与不全等运算符 不仅比较值 还比较类型

    console.log(10 === 10);// true

    console.log('10' === 10);// false
    console.log('10' == 10);// true

fonction

la fonction isNaN() est utilisée pour déterminer si son paramètre For NaN valeurs (valeurs non numériques)
Fonction : Déterminer si la valeur actuelle est NaN
true - indique que la valeur actuelle est NaN (pas une valeur numérique)
false - indique que la valeur actuelle est not NaN (pas une valeur numérique) )
fonction isFinite()
Fonction - Détermine si la valeur actuelle est infinie

false - Indique que la valeur actuelle est l'infini

    console.log(isNaN(100));// false
    console.log(isNaN(Number('卧龙学苑')));// true

    var result = 100/0;
    console.log(result);// Infinity
    //isFinite()函数
    console.log(isFinite(result));// false

true - Indique que la valeur actuelle est un valeur finie

Opérateur ET logique

L'utilisation de base des opérateurs JavaScript est destinée aux calculs de types booléens
Opérateur ET logique si les deux opérandes sont de type booléen Si tel est le cas, le résultat renvoyé est vrai uniquement lorsque les deux opérandes sont vrais, sinon ils sont tous les deux faux
1 Convertissez les deux opérandes de l'opérateur logique ET en type booléen

2. l'opérande de gauche Lorsqu'il est vrai, le résultat est la valeur de l'opérande de droite

    console.log(true && true);// true
    console.log(true && false);// false
    console.log(false && true);// false
    console.log(false && false);// false

    console.log(100 && 1);// 1
    console.log(1 && 0);// 0
    console.log(0 && 1);// 0
    console.log(0 && 0);// 0

    console.log(true && true);
    console.log(true && false);
    console.log(false && true);
    console.log(false && false);

    console.log('卧龙学苑' && '卧龙学苑');// 卧龙学苑
    console.log('卧龙学苑' && '');// ''
    console.log('' && '卧龙学苑');// ''
    console.log('' && '');// ''

    console.log('卧龙学苑' && 1);// 1
    console.log(false && 0);// false

3 Lorsque l'opérande de gauche est faux, le résultat est la valeur de l'opérande de gauche

• <. 🎜>

  Opérateur OU logique

Lors de l'utilisation de l'opérateur OU logique, si les deux opérandes sont de type booléen, le résultat renvoyé est vrai uniquement lorsque l'un des opérandes est vrai, sinon les deux sont faux

    console.log(true || true);// true
    console.log(true || false);// true
    console.log(false || true);// true
    console.log(false || false);// false

    console.log(100 || 1);// 100
    console.log(1 || 0);// 1
    console.log(0 || 1);// 1
    console.log(0 || 0);// 0

    console.log(true || true);
    console.log(true || false);
    console.log(false || true);
    console.log(false || false);

    console.log('卧龙学苑' || '卧龙学苑');// 卧龙学苑
    console.log('卧龙学苑' || '');// 卧龙学苑
    console.log('' || '卧龙学苑');// 卧龙学苑
    console.log('' || '');// ''

• Opérateur de répartition d'affectation

L'opérateur d'affectation en langage JavaScript est utilisé pour attribuer des valeurs à des variables ou des propriétés
Langage JavaScript L'opérateur d'expansion d'affectation dans est en fait un mode abrégé d'opérateur d'affectation et d'opérateur arithmétique utilisé ensemble

L'opérateur d'expansion d'affectation dans le langage JavaScript a une efficacité d'exécution plus élevée<🎜>

    var b = 10, c = 20;

    var a = b + c;
    console.log(a);// 30

    // b = b + c;
    // 等价写法 - 赋值扩展运算符的性能要比赋值运算符更高
    b += c;
    console.log(b);// 30

• 条件运算符

条件运算符 首先判断一个表达式是真是假 然后根据判断结果执行两个给指定指令中的一个

    var result = 8 > 9 ? '对' : '错';
    console.log(result);

    var score = 95;
    score > 90 ? console.log('优秀') : console.log('及格');

• 嵌套条件运算符

条件运算符中 每个表达式可以又是一个条件运算表达式 称为条件运算的嵌套
优点:扩展了条件运算符本身的计算能力
缺点:可读性比较差 性能随着嵌套的层级越多越差
建议:不要最多不要超过三层嵌套

    var score = 55;

    var result = score > 90 ? '优秀' : (score > 80 ? '良好' : (score > 60 ? '及格' : '不及格'));
    console.log(result);

相关推荐：

js比较和逻辑运算符的介绍

运算符优先级-PHP运算符优先级

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!