Vergleich der Priorität von js-Operatoren und Analyse der logischen js-Operatoren

Dieser Artikel enthält eine detaillierte Erläuterung der verschiedenen Kategorien von Operatoren und beschreibt anschließend die Priorität von js-Operatoren. Priorität bezieht sich auf die berechnete Prioritätsstufe des Operators, die im Folgenden ausführlich vorgestellt wird.

Wie vergleiche ich Operatoren in js? Vergleichsoperatoren in der JavaScript-Sprache werden hauptsächlich verwendet, um zu vergleichen, ob die Werte zweier Operanden gleich sind oder ob sie gleich groß sind. Der Artikel hat Referenzwert und kann bei Bedarf abgeholt werden.

Operatorübersicht

JavaScript bietet eine Reihe von Operatoren zum Bearbeiten von Datenwerten, auch bekannt als Operatoren
Operatoren können entsprechend ihrer unterschiedlichen Funktionen oder der Anzahl der manipulierten Variablenkategorie bedient werden

• Arithmetische Operatoren

1. Wenn einer oder beide Operanden String-Typen sind, wandelt JavaScript sie bei der Durchführung von Berechnungen automatisch in numerische Werte um
2. Wenn einer der Operanden vom Typ String ist, die Zeichen jedoch keine Zahlen sind, konvertiert JavaScript den numerischen Wert automatisch in ein NaN-Ergebnis
3. Jeder Operand ist ein NaN-Ergebnis. Beide sind NaN
4 ​​falsch und wahr werden zur Berechnung in 0 und 1 umgewandelt

• Additionsoperator

1 .Wenn beide Operanden numerische Werte sind, Addition Berechnung wird durchgeführt
2. Wenn eine String-Additionsberechnung durchgeführt wird – String-Verkettungsoperator (String-String)
3. Wenn boolescher Typ hinzugefügt wird, Berechnung – Boolesche Typkonvertierung in numerischen Wert und dann Additionsberechnung

• Subtraktionsoperator

1. Konvertieren Sie vor der Subtraktionsoperation andere Typen in den Zahlentyp und führen Sie dann die Berechnung durch
2. Wenn die Zeichenfolge subtrahiert wird, konvertieren Sie die String-Typ in einen numerischen Wert umwandeln und dann die Subtraktion durchführen
3. Wenn der boolesche Typ subtrahiert wird – konvertieren Sie den booleschen Typ in einen numerischen Wert und führen Sie dann die Subtraktionsberechnung durch

• Rest Operator

Der Restoperator wird verwendet, um den Rest zu berechnen, nachdem die beiden Operanden geteilt wurden
Ob eine positive oder eine negative Zahl ist, hängt davon ab, ob der erste Operand positiv oder negativ ist ( es hat nichts mit dem zweiten zu tun)

    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

• Inkrementierungsoperator und Dekrementierungsoperator

Der automatische Inkrementierungsoperator wird verwendet, um 1 zu addieren Es ist unterteilt in:
a. Der Auto-Inkrement-Operator wird vor dem Operanden platziert und fügt 1 hinzu, bevor er den Wert zuweist

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

b .Post-Inkrement-Typ: Der Auto-Inkrement-Operator befindet sich hinter dem Operanden, weist zuerst den Wert zu und addiert dann 1

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

Der Auto-Dekrement-Operator wird für ganzzahlige Werte -1 nacheinander verwendet und ist unterteilt in:
a . Vorpositionierungstyp: Automatische Dekrementierungsoperation. Wenn sich der Operator vor dem Operanden befindet, dekrementieren Sie ihn um 1 und weisen Sie dann den Wert zu Dekrementieren Sie es um 1

• Operation Die Prioritätsebene des Operators Der Operator hat die Prioritätsebene der Berechnung
  1 . Operatoren mit höherer Prioritätsstufe werden zuerst berechnet
  2. Operatoren haben die gleiche Stufe und werden von links nach rechts berechnet
  3. Der Operator mit der höchsten Priorität ist „()“
  4. Ausdrücke, die sind Zuerst ausgewertet werden mit „()“ umschlossen
  

    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

• Vergleichsoperatoren

Vergleichsoperatoren in der JavaScript-Sprache werden hauptsächlich verwendet, um zu vergleichen, ob die Werte zweier Operanden gleich sind oder die Größe

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

    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

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

Der Unterschied zwischen Gleichheitsvergleichsoperator

* und Zuweisungsoperator
*Zuweisungsoperator ( =)
*Gleichheitsvergleichsoperator (==)
Ungleichheitsvergleichsoperator
* Symbol ist „!="
* ist nicht „"
Nur ​​Gleichheits- und Ungleichheitsvergleichsoperatoren Vergleichen Sie die Werte der Operanden und vergleichen Sie keine Typen

    // 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

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

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

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

• Funktion

isNaN() Funktion wird verwendet, um zu bestimmen, ob sein Parameter ist ein NaN-Wert (nicht numerischer Wert)

Funktion: Bestimmen, ob der aktuelle Wert NaN ist
true – Zeigt an, dass der aktuelle Wert NaN (kein numerischer Wert) ist
false – Zeigt an, dass der aktuelle Wert ist kein NaN (kein numerischer Wert)
isFinite()-Funktion
Funktion – Bestimmt, ob der aktuelle Wert unendlich ist
false – Zeigt an, dass der aktuelle Wert unendlich ist
true – Zeigt an, dass der aktuelle Wert ist ein endlicher Wert

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

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

• Logischer UND-Operator

Grundlegende Verwendung von JavaScript-Operatoren Wird für Berechnungen vom booleschen Typ

Logisches UND verwendet Wenn beide Operanden vom booleschen Typ sind, ist das zurückgegebene Ergebnis nur dann wahr, wenn beide Operanden wahr sind. Andernfalls werden die beiden Operanden des logischen UND-Operators in den booleschen Typ umgewandelt.
2. Wenn der linke Operand wahr ist, ist das Ergebnis der Wert des rechten Operanden
3. Wenn der linke Operand falsch ist, ist das Ergebnis der linke Der Wert des Operanden

    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

Logischer ODER-Operator
Bei Verwendung des logischen ODER-Operators nur, wenn beide Operanden vom booleschen Typ sind. Das zurückgegebene Ergebnis ist wahr, wenn eine der Operationstypnummern wahr ist, andernfalls ist es falsch

    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('' || '');// ''

Erweiterter Zuweisungsoperator
JavaScript Der Zuweisungsoperator in der Sprache wird verwendet, um Variablen oder Attributen Werte zuzuweisen

Der Der Zuweisungserweiterungsoperator in der JavaScript-Sprache ist eigentlich der Abkürzungsmodus des Zuweisungsoperators und des arithmetischen Operators, die zusammen verwendet werden

Der Zuweisungserweiterungsoperator in der JavaScript-Sprache Die Ausführungseffizienz des Symbols ist höher

    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运算符优先级

Das obige ist der detaillierte Inhalt vonVergleich der Priorität von js-Operatoren und Analyse der logischen js-Operatoren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!