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.
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);//NaNInkrementierungsoperator 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);// 16Vergleichsoperatoren
一.大于与小于比较运算符
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('a' < 'b');//true
console.log('a' > 'A');//true
console.log('abc' > 'cba');//false
console.log('abc' > 'acd');//false
console.log('我' > '你');//true二.相等与不等比较运算符
* 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);// trueFunktion: 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));// falseLogisches 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
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('' || '');// ''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);相关推荐：
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!
