IT-Kurs JavaScript-Grundlagen 040_Operatoren

JavaScript-Operatoren werden für mathematische Operationen, Vergleiche, logische Operationen und andere Vorgänge verwendet und geben Ergebnisse zurück.

Arithmetische Operatoren

• +: Addition
• -: Subtraktion
• *: Multiplikation
• /: Division
• %: Modulo (Rest)
• **: Potenzierung

Beispiel:

1
let a = 5;
2
let b = 2;
3

4
console.log(a + b);  // Ausgabe 7
5
console.log(a - b);  // Ausgabe 3
6
console.log(a * b);  // Ausgabe 10
7
console.log(a / b);  // Ausgabe 2.5
8
console.log(a % b);  // Ausgabe 1
9
console.log(a**b);  // Ausgabe 25

Zuweisungsoperatoren

• =: Zuweisung
• +=: Additionszuweisung
• -=: Subtraktionszuweisung
• *=: Multiplikationszuweisung
• /=: Divisionszuweisung
• %=: Modulo-Zuweisung
• **=: Potenzierungszuweisung
• ??=: Nullish-Zuweisung, Zuweisung erfolgt nur, wenn der Variablenwert null oder undefined ist

Beispiel:

1
let x = 5;
2
x += 2;  // x = x + 2; Ausgabe 7
3
x -= 2;  // x = x - 2; Ausgabe 3
4
x *= 2;  // x = x * 2; Ausgabe 10
5
x /= 2;  // x = x / 2; Ausgabe 2.5
6
x %= 2;  // x = x % 2; Ausgabe 1
7
x **= 2;  // x = x ** 2; Ausgabe 25
8
x ??= 2;  // Ausgabe 5, weist 2 zu, wenn x null oder undefined ist
9
console.log(x);

Vergleichsoperatoren

• ==: Gleichheit (Werttyp wird automatisch konvertiert)
• ===: Strikte Gleichheit (Wert und Typ sind gleich)
• !=: Ungleichheit
• !==: Strikte Ungleichheit
• >: Größer als
• <: Kleiner als
• >=: Größer oder gleich
• <=: Kleiner oder gleich

Wenn nicht-numerische Werte auftreten, werden sie zuerst in numerische Werte konvertiert und dann verglichen. Bei Strings wird Zeichen für Zeichen der Unicode-Wert verglichen.

Beispiel:

1
let a = 5;
2
let b = '5';
3
let c = 10;
4

5
console.log(a == b);   // Ausgabe true, Werte sind gleich
6
console.log(a === b);  // Ausgabe false, Typen sind nicht gleich
7
console.log(a != b);   // Ausgabe false, Werte sind gleich
8
console.log(a !== b);  // Ausgabe true, Typen sind nicht gleich
9
console.log(a > c);  // Ausgabe false, 5 < 10
10
console.log(a < c);  // Ausgabe true, 5 < 10
11
console.log(a >= c);  // Ausgabe false, 5 <= 10
12
console.log(a <= c);  // Ausgabe true, 5 <= 10

Logische Operatoren

Logische Operatoren konvertieren Operanden beim Verarbeiten in boolesche Werte und geben den ursprünglichen Wert dieses Operanden zurück.

&&: Logisches UND

Wird verwendet, um zu prüfen, ob alle Bedingungen gleichzeitig true sind. Wenn alle Bedingungen true sind, ist das Ergebnis des gesamten Ausdrucks true; andernfalls ist das Ergebnis false. Die UND-Operation sucht von links nach rechts nach dem ersten false. Wenn false gefunden wird, stoppt die Berechnung und gibt den ursprünglichen Wert dieses Operanden zurück (Kurzschlussauswertung). Gibt es am Ende kein false, wird das letzte true zurückgegeben.

||: Logisches ODER

Wird verwendet, um zu prüfen, ob mindestens eine Bedingung true ist. Wenn mindestens eine Bedingung true ist, ist das Ergebnis des gesamten Ausdrucks true; wenn alle Bedingungen false sind, ist das Ergebnis false. Die ODER-Operation sucht von links nach rechts nach dem ersten true. Wenn true gefunden wird, stoppt die Berechnung und gibt den ursprünglichen Wert dieses Operanden zurück (Kurzschlussauswertung). Gibt es am Ende kein true, wird das letzte false zurückgegeben.

!: Logisches NICHT

Wird verwendet, um einen booleschen Wert zu negieren. Wenn ein Wert true ist, wird er mit dem logischen NICHT-Operator zu false negiert; wenn ein Wert false ist, wird er zu true negiert. Logisches NICHT kann auch verwendet werden, um nicht-boolesche Werte in boolesche Werte umzuwandeln. Es konvertiert alle Werte außer null, undefined, 0, NaN, "" (leerer String) zu true, während diese Werte selbst zu false konvertiert werden.

Beispiel:

1
let a = true;
2
let b = false;
3
let c = "hello";
4
let d = null;
5

6
console.log(a && b);  // Ausgabe false
7
console.log(c && d);  // Ausgabe null
8
console.log(a || b);  // Ausgabe true
9
console.log(c || d);  // Ausgabe hello
10
console.log(!a);      // Ausgabe false
11
console.log(!d);      // Ausgabe true

Ternärer Operator

• condition ? expr1 : expr2: Wenn die Bedingung wahr ist, wird expr1 zurückgegeben, andernfalls expr2.

Beispiel:

1
let age = 18;
2
let status = (age >= 18) ? 'Erwachsener' : 'Minderjähriger';
3
console.log(status);  // Ausgabe 'Erwachsener'

Nullish Coalescing Operator

Der Nullish Coalescing Operator ist ein Operator zur Behandlung von Standardwerten, der üblicherweise verwendet wird, um sicherzustellen, dass eine Variable einen nicht-nullen Wert (weder null noch undefined) hat. Die Syntax dieses Operators ist ??.

Bei Verwendung des Nullish Coalescing Operators wird der erste definierte (weder null noch undefined) Operand zurückgegeben. Wenn der erste Operand null oder undefined ist, wird der zweite Operand zurückgegeben.

Beispiel:

1
let num1 = 0;
2
let num2 = 1;
3
let result = num1 ?? num2;
4
console.log(result);  // Ausgabe 0, da num nicht null oder undefined ist
5

6
let user;
7
console.log(user ?? "Anonym"); // Ausgabe Anonym, da user undefiniert ist

Bitweise Operatoren

• &: Bitweises UND
• |: Bitweises ODER
• ^: Bitweises XOR
• ~: Bitweise Negation
• <<: Linksverschiebung
• >>: Rechtsverschiebung
• >>>: Vorzeichenlose Rechtsverschiebung

Beispiel:

1
let a = 5;  // Binär: 0101
2
let b = 3;  // Binär: 0011
3

4
console.log(a & b);   // Ausgabe 1 (Bitweises UND)
5
console.log(a | b);   // Ausgabe 7 (Bitweises ODER)
6
console.log(a ^ b);   // Ausgabe 6 (Bitweises XOR)
7
console.log(~a);      // Ausgabe -6 (Bitweise Negation)
8
console.log(a << 1);  // Ausgabe 10 (Linksverschiebung)
9
console.log(a >> 1);  // Ausgabe 2 (Rechtsverschiebung)

Weitere Operatoren

• typeof: Gibt einen String zurück, der den Typ des nicht ausgewerteten Operanden angibt.
• instanceof: Wird verwendet, um zu testen, ob ein Objekt eine Instanz eines bestimmten Typs ist.

Beispiel:

1
let str = 'Hello';
2
console.log(typeof str);  // Ausgabe 'string'
3

4
let arr = [1, 2, 3];
5
console.log(arr instanceof Array);  // Ausgabe true

+ (Plus)

In JavaScript hat das Plus + mehrere Verwendungszwecke, einschließlich mathematischer Operationen, String-Verkettung und unärer Operationen.

Mathematische Operation

Beispiel:

1
let a = 5;
2
let b = 3;
3
let result = a + b;
4
console.log(result);  // Ausgabe 8

Wenn beide Zahlen sind, wird + für mathematische Addition verwendet.

String-Verkettung

Beispiel:

1
let str1 = 'Hello';
2
let str2 = ' World';
3
let result = str1 + str2;
4
console.log(result);  // Ausgabe 'Hello World'

Wenn einer der Operanden ein String ist, führt + eine String-Verkettung durch.

Unärer Plus-Operator

Beispiel:

1
let str = '42';
2
let num = +str;
3
console.log(num);  // Ausgabe 42

Wenn + vor einem einzelnen Operanden verwendet wird, kann es den Operanden in eine Zahl umwandeln. Dies ist die Funktion des unären Plus-Operators.

Typkonvertierung

Beispiel:

1
let num = 42;
2
let str = '10';
3
let result = num + str;  // Implizite Typkonvertierung (Type Coercion)
4
console.log(result);  // Ausgabe '4210'

Wenn einer der Operanden ein String ist, führt + eine Typkonvertierung durch, konvertiert die anderen Operanden in Strings und führt dann eine String-Verkettung durch.

Verkettung von Arrays

Beispiel:

1
let arr1 = [1, 2, 3];
2
let arr2 = [4, 5, 6];
3
let result = arr1 + arr2;
4
console.log(result);  // Ausgabe '1,2,34,5,6'

Wenn ein Operand ein Array ist, konvertiert + das Array in einen String und führt dann eine String-Verkettung durch.

Sonderfälle

Beispiel:

1
let specialResult1 = '1' + 2 + 3;
2
console.log(specialResult1);  // Ausgabe '123'
3

4
let specialResult2 =  2 + 3 + '1';
5
console.log(specialResult2);  // Ausgabe '51'

specialResult1: Da der String ganz links bei + steht, werden die nachfolgenden Zahlen als Strings verkettet. specialResult2: Da der String ganz rechts bei + steht, werden die vorherigen Zahlen zuerst mathematisch addiert und dann verkettet.

- (Minus)

In JavaScript ist das Minus - ein Operator zur Durchführung mathematischer Subtraktion.

Mathematische Subtraktion

Beispiel:

1
let a = 5;
2
let b = 3;
3
let result = a - b;
4
console.log(result);  // Ausgabe 2

Wenn beide Zahlen sind, wird - für mathematische Subtraktion verwendet.

Unärer Minus-Operator

Beispiel:

1
let num = 42;
2
let result = -num;
3
console.log(result);  // Ausgabe -42

Wenn - vor einem einzelnen Operanden verwendet wird, kann es eine unäre Subtraktion durchführen und den Operanden in seine Gegenzahl umwandeln.

Typkonvertierung

Beispiel:

1
let num1 = 42;
2
let str = '10';
3
let result = num1 - str;
4
console.log(result);  // Ausgabe 32

Wenn einer der Operanden ein String ist, führt - eine Typkonvertierung durch, konvertiert die anderen Operanden in Zahlen und führt dann eine mathematische Subtraktion durch.

Sonderfall

Beispiel:

1
let specialResult = '10' - 2;
2
console.log(specialResult);  // Ausgabe 8

In diesem Sonderfall kann der Inhalt des Strings erfolgreich in eine Zahl konvertiert werden, daher führt - eine mathematische Subtraktion durch.

=、==、=== (Zuweisung, lockere Gleichheit, strikte Gleichheit)

In JavaScript ist das Gleichheitszeichen = ein Zuweisungsoperator, während == und === Vergleichsoperatoren sind. Lockere Gleichheit konvertiert beide Operanden in denselben Typ und vergleicht sie dann. Bei bedingten Prüfungen wird normalerweise === für strikte Gleichheitsvergleiche verwendet, da es keine Typkonvertierung durchführt.

Zuweisungsoperator

= wird verwendet, um den Wert auf der rechten Seite der Variable auf der linken Seite zuzuweisen.

Beispiel:

1
let x = 5;
2
let y = 'Hello';
3
console.log(x);  // Ausgabe 5
4
console.log(y);  // Ausgabe 'Hello'

In diesem Beispiel weist = den Wert auf der rechten Seite den Variablen x und y auf der linken Seite zu.

Vergleichsoperatoren

== und === werden verwendet, um die Gleichheit zweier Werte zu vergleichen.

Beispiel:

1
let a = 5;
2
let b = '5';
3

4
console.log(a == b);   // Ausgabe true
5
console.log(a === b);  // Ausgabe false

Bei Gleichheitsvergleichen mit == wird eine Typkonvertierung durchgeführt, null == undefined gibt true aus. Bei Gleichheitsvergleichen mit === müssen Wert und Typ gleich sein, null === undefined gibt false aus. NaN ist nicht gleich irgendeinem Wert, einschließlich NaN selbst.

++、-- (Inkrement, Dekrement)

In JavaScript sind Inkrement (++) und Dekrement (--) Operatoren, die verwendet werden, um den Wert einer Variablen zu erhöhen oder zu verringern.

Inkrement-Operator (++)

Nach der Verwendung wird die ursprüngliche Variable sofort um 1 erhöht. Präfix-Inkrement gibt den inkrementierten Wert (neuer Wert) zurück; Postfix-Inkrement gibt den Wert vor dem Inkrement (alter Wert) zurück;

Beispiel für Präfix-Inkrement:

1
let a = 5;
2
// Präfix-Inkrement, zuerst um 1 erhöhen, dann den neuen Wert verwenden
3
let b = ++a;
4
console.log(b);  // Ausgabe 6
5
console.log(a);  // Ausgabe 6

In diesem Beispiel wurde a zuerst um 1 erhöht, dann erhielt b den neuen Wert von a (6).

Beispiel für Postfix-Inkrement:

1
let x = 5;
2
// Postfix-Inkrement, zuerst den aktuellen Wert verwenden, dann um 1 erhöhen
3
let y = x++;
4
console.log(y);  // Ausgabe 5
5
console.log(x);  // Ausgabe 6

In diesem Beispiel erhielt y zuerst den aktuellen Wert von x (5), dann wurde der Wert von x um 1 erhöht.

Dekrement-Operator (—)

Nach der Verwendung wird die ursprüngliche Variable sofort um 1 verringert. Präfix-Dekrement gibt den dekrementierten Wert (neuer Wert) zurück; Postfix-Dekrement gibt den Wert vor dem Dekrement (alter Wert) zurück;

Beispiel für Präfix-Dekrement:

1
let p = 10;
2
// Präfix-Dekrement, zuerst um 1 verringern, dann den neuen Wert verwenden
3
let q = --p;
4
console.log(q);  // Ausgabe 9
5
console.log(p);  // Ausgabe 9

In diesem Beispiel wurde p zuerst um 1 verringert, dann erhielt q den neuen Wert von p (9).

Beispiel für Postfix-Dekrement:

1
let m = 8;
2
// Postfix-Dekrement, zuerst den aktuellen Wert verwenden, dann um 1 verringern
3
let n = m--;
4
console.log(n);  // Ausgabe 8
5
console.log(m);  // Ausgabe 7

In diesem Beispiel erhielt n zuerst den aktuellen Wert von m (8), dann wurde der Wert von m um 1 verringert.

Operatorpriorität:

https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Operators/Operator_precedence