Operatoren in JavaScript

In diesem Artikel erklären wir die Operatoren in JavaScript.

YouTube Video

Operatoren in JavaScript

Operatoren in JavaScript sind Symbole oder Schlüsselwörter, die verwendet werden, um Berechnungen oder Vergleiche mit Zahlen und Variablen durchzuführen. Es gibt verschiedene Arten von Operatoren, die jeweils unterschiedliche Operationen ausführen. Hier sind einige der wichtigsten Operatoren zusammengefasst:.

Arithmetische Operatoren

JavaScripts arithmetische Operatoren umfassen die folgenden:.

 1let a = 10; // Initialize variable 'a' with the value 10
 2let b = 3;  // Initialize variable 'b' with the value 3
 3
 4// Perform and display arithmetic operations between 'a' and 'b'
 5console.log("Addition (a + b):      ", a + b); // 13
 6console.log("Subtraction (a - b):   ", a - b); // 7
 7console.log("Multiplication (a * b):", a * b); // 30
 8console.log("Division (a / b):      ", a / b); // 3.333...
 9console.log("Modulus (a % b):       ", a % b); // 1
10
11// Demonstrate post-increment operation on 'a'
12// Output the current value of 'a' (10), then increment
13console.log("Post-increment (a++):  ", a++);
14// Display the incremented value of 'a' (11)
15console.log("Value of 'a' after increment:", a);
16
17// Demonstrate pre-increment operation on 'a'
18// Increment 'a' first (12) then output
19console.log("Pre-increment (++a):   ", ++a);
20
21// Demonstrate post-decrement operation on 'a'
22// Output the current value of 'a' (12), then decrement
23console.log("Post-decrement (a--):  ", a--);
24// Display the decremented value of 'a' (11)
25console.log("Value of 'a' after decrement:", a);
26
27// Demonstrate pre-decrement operation on 'a'
28// Decrement 'a' first (10) then output
29console.log("Pre-decrement (--a):   ", --a);

Arithmetische Operatoren führen grundlegende mathematische Operationen mit Zahlen durch. Neben Addition und Subtraktion können Sie auch Operationen wie Modulus, Inkrement und Dekrement durchführen. Beachten Sie, dass der zurückgegebene Wert bei Inkrement- oder Dekrementoperationen davon abhängt, ob der Operator vor oder nach dem Operanden steht.

Zuweisungsoperatoren

JavaScripts Zuweisungsoperatoren umfassen die folgenden:.

 1let x = 10;
 2
 3x += 5;  // x = x + 5, so x becomes 15
 4console.log('After x += 5 : ', x);  // 15
 5
 6x -= 10;
 7console.log('After x -= 10 : ', x);  // 5
 8
 9x *= 3;
10console.log('After x *= 3 : ', x);  // 15
11
12x /= 3;
13console.log('After x /= 3 : ', x);  // 5
14
15x %= 2;
16console.log('After x %= 2 : ', x);  // 1

Zuweisungsoperatoren werden verwendet, um Variablen Werte zuzuweisen oder deren Werte zu aktualisieren. Zusätzlich zu normalen Zuweisungen gibt es Zuweisungsoperatoren für arithmetische Operationen wie Addition und Modulo.

Vergleichsoperatoren

JavaScripts Vergleichsoperatoren umfassen die folgenden:.

 1console.log("5 == '5' evaluates to:", 5 == "5");   // true (because the values are equal)
 2console.log("5 === '5' evaluates to:", 5 === "5"); // false (because the types are different)
 3console.log("5 != '5' evaluates to:", 5 != "5");   // false
 4console.log("5 !== '5' evaluates to:", 5 !== "5"); // true
 5console.log("5 > 2 evaluates to:", 5 > 2);         // true
 6console.log("5 < 2 evaluates to:", 5 < 2);         // false
 7console.log("5 >= 5 evaluates to:", 5 >= 5);       // true
 8console.log("5 <= 4 evaluates to:", 5 <= 4);       // false
 9console.log("5 >= '5' evaluates to:", 5 >= "5");   // true
10console.log("5 <= '5' evaluates to:", 5 <= "5");   // true

• Vergleichsoperatoren vergleichen Werte und geben entweder wahr oder falsch zurück.
• Der Gleichheitsoperator (==) konvertiert verschiedene Typen automatisch, falls nötig, bevor der Vergleich durchgeführt wird. Der strikte Gleichheitsoperator (===) führt während des Vergleichs keine Typkonvertierung durch und gibt nur true zurück, wenn beide Werte denselben Typ und denselben Wert haben. Die Verwendung des strikten Gleichheitsoperators (===) hilft, Fehler durch unbeabsichtigte Typkonvertierungen zu vermeiden, daher wird empfohlen, ihn bevorzugt einzusetzen.

Logische Operatoren

JavaScripts logische Operatoren umfassen die folgenden:.

1let a = true;
2let b = false;
3
4console.log("a && b evaluates to:", a && b);  // false
5console.log("a || b evaluates to:", a || b);  // true
6console.log("!a evaluates to:", !a);          // false

Logische Operatoren werden verwendet, wenn mehrere Bedingungen vorliegen, um Kombinationen von Bedingungen zu bewerten.

Priorität der logischen Operatoren

In JavaScript werden logische Operatoren im Allgemeinen in der Reihenfolge NOT zuerst, gefolgt von AND und schließlich OR ausgewertet.

NOT hat die höchste Priorität

NOT ist ein unärer Operator und wird mit der höchsten Priorität ausgewertet.

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

AND hat eine höhere Priorität als OR

AND hat eine höhere Priorität als OR, daher wird der AND-Teil zuerst ausgewertet.

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

Auf diese Weise wird der AND-Teil (&&) zuerst ausgewertet, und sein Ergebnis wird an OR (||) übergeben.

AND und OR führen eine Kurzschlussauswertung durch

JavaScripts AND und OR führen eine Kurzschlussauswertung durch. Wenn das Ergebnis durch den linken Wert bestimmt werden kann, wird der rechte Ausdruck nicht ausgewertet.

1let a = false && console.log("This will not be printed");
2console.log(a);  // false
3
4let b = true || console.log("This will not be printed");
5console.log(b);  // true

In beiden Fällen wird console.log() nicht ausgeführt.

Explizite Priorität festlegen

Durch das explizite Gruppieren von Ausdrücken mit Klammern können Missverständnisse über die Priorität verhindert werden.

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

Unterschiede zwischen natürlicher Sprache und Programminterpretation

Beim Verwenden logischer Operatoren ist es wichtig, sich der Mehrdeutigkeiten in der natürlichen Sprache bewusst zu sein. Zum Beispiel kann 'weißer Hund oder Katze' entweder 'ein weißer Hund oder eine beliebige Farbe von Katze' oder 'ein weißer Hund oder eine weiße Katze' bedeuten. Im Code würde es so aussehen:.

1if (isWhite && isDog || isCat) {
2    console.log(' "A white dog" or "a cat of any color" ');
3}
4
5if (isWhite && (isDog || isCat)) {
6    console.log(' "A white dog" or "a white cat" ');
7}
8
9console.log(true || (false && false));  // true

Da natürliche Sprache solche Mehrdeutigkeiten enthält, ist beim Codieren oder Gestalten Vorsicht geboten.

Ternärer Operator (Bedingungsoperator)

JavaScript enthält einen ternären Operator (Bedingungsoperator).

1let age = 20;
2let message = age >= 18 ? "Adult" : "Minor";
3console.log(message);  // "Adult"

Es wird in der Form geschrieben: Bedingung ? Wert, wenn wahr : Wert, wenn falsch.

Bitweise Operatoren

JavaScript-Bitweisenoperatoren umfassen die folgenden.

 1let x = 0x0F & 0x0C;
 2console.log("0x0F & 0x0C evaluates to:", x, "(0x0C, 12)");  // 0x0C (12)
 3
 4x = 0x04 | 0x02;
 5console.log("0x04 | 0x02 evaluates to:", x, "(0x06, 6)");  // 0x06 (6)
 6
 7x = 0x0F ^ 0x0C;
 8console.log("0x0F ^ 0x0C evaluates to:", x, "(0x03, 3)");  // 0x03 (3)
 9
10// The inverted number is represented as a negative value
11// because JavaScript numbers are stored as signed 32-bit integers.
12x = ~0x0C;
13console.log("~0x0C evaluates to:", x, "(-13, 0xF3)");  // 0xF3 (-13)
14
15x = 0x04 << 1;
16console.log("0x04 << 1 evaluates to:", x, "(0x08, 8)");    // 0x08 (8)
17x = 0x04 >> 1;
18console.log("0x04 >> 1 evaluates to:", x, "(0x02, 2)");    // 0x02 (2)

Bitweise Operatoren führen Berechnungen auf Zahlen auf Bit-Ebene durch. Sie werden normalerweise für die Low-Level-Verarbeitung verwendet.

Typ-Operatoren

JavaScript-Typoperatoren umfassen die folgenden.

1console.log(typeof "Hello");  // "string"
2console.log(typeof 42);       // "number"
3
4let arr = [1, 2, 3];
5console.log("arr instanceof Array : ", arr instanceof Array); // true

Typ-Operatoren werden verwendet, um den Typ eines Werts zu überprüfen oder ihn in einen bestimmten Typ zu konvertieren.

Der Operator typeof gibt den Typ einer Variable zurück.

Der Operator instanceof überprüft, ob ein Objekt zu einer bestimmten Klasse gehört.

Zusammenfassung

• Arithmetische Operatoren führen grundlegende Berechnungen durch.
• Zuweisungsoperatoren weisen Variablen Werte zu oder aktualisieren diese.
• Vergleichsoperatoren vergleichen zwei Werte und geben true oder false zurück.
• Logische Operatoren bewerten Kombinationen von Bedingungen.
• Ternäre Operatoren ermöglichen es Ihnen, bedingte Anweisungen in einer kürzeren Form als if zu schreiben.
• Bitweise Operatoren führen Berechnungen auf Bit-Ebene durch.
• Typ-Operatoren ermöglichen es, den Typ eines Werts zu überprüfen.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video