Lassen Sie uns über JavaScript-Operatoren sprechen

Operator, auch Operator genannt, ist ein Symbol, das zur Implementierung von Funktionen wie Zuweisung, Vergleich und Durchführung arithmetischer Operationen verwendet wird.

Häufig verwendete Operatoren in JavaScript sind:

• Arithmetische Operatoren
• Inkrement- und Dekrementoperatoren
• Vergleichsoperatoren
• Logische Operatoren
• Zuweisungsoperatoren

arithmetischer Operatoren

: In arithmetischen Operationen verwendete Symbole, mit denen arithmetische Operationen an zwei Variablen oder Werten ausgeführt werden.

console.log(1 + 1); //2
    console.log(1 - 1); //0
    console.log(1 * 1); //1
    console.log(1 / 1); //1
    console.log(4 % 2); //0

Gleitkommazahlen weisen Fehler bei arithmetischen Operationen auf (direkte Teilnahme an Berechnungen vermeiden):

console.log(0.1 + 0.2); //0.30000000000000004

kann nicht direkt bestimmen, ob zwei Gleitkommazahlen vorhanden sind gleich.

var num = 0,1 + 0,2;
    console.log(num == 0.3); //false

• Arithmetische Operatorpriorität: Multiplikation und Division zuerst, Addition und Subtraktion
• Sie können den %-Restoperator verwenden, um zu bestimmen, ob eine Zahl teilbar

ist

und Operatoren Eine Formel, die aus , Variablen usw. besteht, wird als Ausdruck bezeichnet.

Der Ausdruck gibt uns schließlich ein Ergebnis zurück, das als Rückgabewert bezeichnet wird.

Inkrementierungs- und Dekrementierungsoperatoren

Wenn Sie wiederholt 1 zu einer numerischen Variablen addieren oder subtrahieren müssen, können Sie dazu die Inkrementierungsoperatoren ( ++ ) und Dekrementierungsoperatoren ( -- ) verwenden.

Kompliziertes Schreiben:

var num = 1;
    Anzahl = Anzahl + 1;
    Anzahl = Anzahl + 1;
    console.log(num); //3

Präfix-Inkrement-Operator:

++ wird vor die Variable geschrieben

++num Präfix-Inkrement soll um 1 erhöht werden, ähnlich wie num=num+1

var age = 10;
    ++Alter;
    console.log(age);//11 Ähnlich der Verwendungsformel von age = age + 1

: zuerst hinzufügen und dann den Wert zurückgeben

console.log(age);
    var a = 10;
    console.log(++a + 10); //(10+1)+10=21

Post-Inkrement-Operator

++ wird nach der Post-Inkrementierung der Variablen num++ geschrieben

num++ was bedeutet, dass 1 zu sich selbst addiert wird, ähnlich wie num=num+1

var Alter = 10;
    Alter++;
    console.log(age);//11 ähnelt

der Verwendungsformel von age = age + 1: Geben Sie zuerst den ursprünglichen Wert zurück und fügen Sie dann

var a = 10 hinzu;
    console.log(a++ + 10); //10+10=20
    console.log(a); //11

Zusammenfassung der Unterschiede

• Die Pre-Inkrement- und Post-Inkrement-Operatoren können das Schreiben von Code vereinfachen und den Wert einer Variablen +1 einfacher als zuvor machen.
• Bei alleiniger Anwendung sind die Ergebnisse die gleichen.
• Bei Verwendung in Verbindung mit anderen Codes sind die Ausführungsergebnisse unterschiedlich.
• Präposition: zuerst sich selbst addieren, dann Berechnungen durchführen ( zuerst sich selbst, dann die anderen )
• Postposition: zuerst die Berechnung anhand des Originalwerts durchführen, dann sich selbst addieren ( zuerst eins, dann sich selbst )
• Bei der Entwicklung wird meistens Postfix-Inkrement/Dekrement verwendet. und der Code belegt eine Zeile. Beispiel: num++;

Übung:

var e = 10;
    var f = e++ + ++e; //1.e++=10 e=11 2.++e=12 f=10+12
    console.log(f); //22

Vergleichsoperatorkonzept

: Der Vergleichsoperator (Relationaloperator) ist ein Operator, der beim Vergleich zweier Daten verwendet wird . Nach der Vergleichsoperation wird ein boolescher Wert (wahr/falsch) als Ergebnis zurückgegeben Vergleichsoperation.

console.log( 2 <= 5); //true
    console.log('Yue Zeyi' = 'persönlicher Blog'); //false
    console.log(17 == '17'); //wahrer Standardkonvertierungsdatentyp, Zeichenfolgentyp wird in numerischen Typ konvertiert console.log(17 = '17'); //falscher Datentyp ist unterschiedlich, Wert und Datentyp sind erforderlich Verwendung konsistenter

des logischen Operators

: Logische Operatoren werden verwendet. Operatoren, die boolesche Operationen ausführen, geben auch einen booleschen Wert zurück. Es wird oft verwendet, um mehrere Bedingungen in der späteren Entwicklung zu beurteilen.

logisch UND

Symbol: && ist wahr, wenn beide Seiten von und

wahr

true true false das Ergebnis false

    console.log(3 < 5 && 3 < 7); //wahres

logisches ODER-

Symbol: || ist äquivalent zu, wenn

beide Seiten von oder false sind, ist das Ergebnis false , solange eine Seite true true

console.log(3 > 5 && 3 > 2); //false
    console.log(3 < 5 && 3 < 7); //wahres

logisches Negationssymbol

: ! Relativ zu nicht

wird die logische Negation auch als Negationssymbol bezeichnet, das verwendet wird, um den entgegengesetzten Wert eines booleschen Werts zu erhalten.

console.log(!true); //false
    console.log(!false); //wahre

Kurzschlussoperation (logische Unterbrechung)

Das Prinzip der Kurzschlussoperation: Wenn mehrere Ausdrücke (Werte) vorhanden sind, kann der Ausdruckswert auf der linken Seite das Ergebnis bestimmen, der Ausdruck auf der rechten Seite wird der Wert der Formel nicht mehr bearbeitet.

Logisches UND:

• Syntax :表达式1 && 表达式2
• Wenn der erste Ausdruck als wahr ausgewertet wird, wird Ausdruck 2 zurückgegeben.
• Wenn der erste Ausdruck als falsch ausgewertet wird, wird Ausdruck 1 zurückgegeben

console.log(123 && 456); //Gibt 456 zurück, alle Zahlen außer 0 sind wahr.
    console.log(123 && 456 && 789); //Zurückgeben 789, in der Reihenfolge zurückschieben console.log(0 && 456); //0

logisches ODER:

• Syntax :表达式1 || 表达式2
• ||

Wenn

• Ausdruck 1 wahr ist
• , wird Ausdruck 2 zurückgegeben

    console.log(123 || 456 || 123 + 456); //123
    console.log(0 || 456 || 123 + 456); //456

Hinweis: Eine logische Unterbrechung führt zu einem Kurzschlussvorgang, dh der nachfolgende Code wird nicht ausgeführt, was sich auf die Ausführungsergebnisse des Programmierers auswirkt.

Varnum = 0;
    console.log(123 || num++); //Logische Unterbrechung führte dazu, dass num++ nicht ausgeführt wurde console.log(num); //0

Zuweisungsoperatorkonzept

: Operator zum Zuweisen von Daten zu Variablen.

var num = 5;
    Anzahl += 10;
    console.log(num); //5+10=15
    Anzahl *= 3;
    console.log(num); //15*3=45

Operatorpriorität Rangfolge

• die logische Nichtpriorität im unären Operator ist sehr hoch.
• Logisches UND hat höhere Priorität als logisches ODER

console.log(4 >= 6 || 'I' != 'you' && !(12 * 2 == 144) && true);
    /* 
    Logische Operatoren werden in vier Abschnitte unterteilt: 1,4 >= 6, um „falsch“ zu erhalten
    2.'I' != 'you' muss wahr sein
    3.!(12 * 2 == 144) wird wahr
    4.wahr
    Beurteilen Sie dann das logische UND: 2 und 3 sind wahr, 3 und 4 sind wahr 
    Dann beurteilen Sie das Logische oder: wahr
     */