Operatoren in TypeScript

Dieser Artikel erklärt Operatoren in TypeScript.

YouTube Video

Operatoren in TypeScript

Operatoren in TypeScript werden verwendet, um numerische Berechnungen, Wertvergleiche und logische Operationen durchzuführen. Da TypeScript ähnliche Operatoren wie JavaScript verwendet, sind sie einfach zu erlernen, aber TypeScript erlaubt strengere Operationen mit Typsicherheit.

Die Hauptoperatoren sind wie folgt:.

Arithmetische Operatoren

Arithmetische Operatoren werden für numerische Berechnungen verwendet.

 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);

Zuweisungsoperatoren

Zuweisungsoperatoren weisen den Wert auf der rechten Seite der Variablen auf der linken Seite zu.

1let z = 5;
2z += 3;
3console.log(z);  // Outputs: 8
4
5z *= 2;
6console.log(z);  // Outputs: 16

Vergleichsoperatoren

Vergleichsoperatoren vergleichen Werte und geben true oder false zurück.

1console.log('5 == "5"   :', 5 == "5");   // Outputs: true
2console.log('5 === "5"  :', 5 === "5");  // Outputs: false
3console.log('5 != "5"   :', 5 != "5");   // Outputs: false
4console.log('5 !== "5"  :', 5 !== "5");  // Outputs: true
5console.log('5 > 3      :', 5 > 3);      // Outputs: true
6console.log('5 < 3      :', 5 < 3);      // Outputs: false
7console.log('5 >= 5     :', 5 >= 5);     // Outputs: true
8console.log('5 <= 3     :', 5 <= 3);     // Outputs: false

Logische Operatoren

Logische Operatoren werden verwendet, um logische Ausdrücke zu kombinieren.

1console.log('true && false :', true && false);  // Outputs: false
2console.log('true || false :', true || false);  // Outputs: true
3console.log('!true         :', !true);          // Outputs: false

Vorrang von logischen Operatoren

In TypeScript werden logische Operatoren normalerweise in der Reihenfolge NICHT zuerst, gefolgt von UND und schließlich ODER ausgewertet.

NICHT hat die höchste Priorität

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

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

UND hat Vorrang vor ODER

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

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

Daher wird der UND-Teil (&&) zuerst berechnet, und sein Ergebnis wird an ODER (||) weitergegeben.

UND und ODER führen eine Kurzschlussauswertung durch

In TypeScript führen UND und ODER eine Kurzschlussauswertung durch. Wenn das Ergebnis durch den linken Wert bestimmt wird, 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.

Vorrang explizit definieren

Die Verwendung von Klammern, um Ausdrücke explizit zu gruppieren, kann Missverständnisse bezüglich des Vorrangs vermeiden.

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

Unterschiede zwischen natürlicher Sprache und Programminterpretation

Beim Verwenden von logischen Operatoren ist es wichtig, sich der Mehrdeutigkeiten in der natürlichen Sprache bewusst zu sein. Zum Beispiel kann der Satz 'ein weißer Hund oder eine Katze' entweder bedeuten 'ein weißer Hund oder irgendeine Katze' oder 'ein weißer Hund oder eine weiße Katze'. Im Code kann es wie folgt geschrieben werden:.

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}

Da natürliche Sprache mehrdeutig sein kann, ist Vorsicht beim Codieren und Entwerfen von Systemen geboten.

Bitweise Operatoren

Bitweise Operatoren manipulieren Zahlen auf Bit-Ebene.

1console.log('5 & 1  :', 5 & 1);   // Outputs: 1  (AND operation)
2console.log('5 | 1  :', 5 | 1);   // Outputs: 5  (OR operation)
3console.log('5 ^ 1  :', 5 ^ 1);   // Outputs: 4  (XOR operation)
4console.log('~5     :', ~5);      // Outputs: -6 (NOT operation)
5console.log('5 << 1 :', 5 << 1);  // Outputs: 10 (Left shift operation)
6console.log('5 >> 1 :', 5 >> 1);  // Outputs: 2  (Right shift operation)
7console.log('5 >>> 1:', 5 >>> 1); // Outputs: 2  (Unsigned right shift operation)

Ternärer Operator

Der ternäre Operator gibt verschiedene Werte basierend auf dem Ergebnis eines bedingten Ausdrucks zurück.

1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access);  // Outputs: Allowed

Typoperatoren

TypeScripts Typoperatoren umfassen Folgendes:.

 1console.log(typeof "Hello");  // "string"
 2console.log(typeof 42);       // "number"
 3
 4let arr: number[] = [1, 2, 3];
 5console.log("arr instanceof Array : ", arr instanceof Array); // true
 6
 7// Example of Type Guard
 8function isString(value: any): value is string {
 9  return typeof value === "string";
10}
11
12let value: any = "Hello";
13if (isString(value)) {
14  console.log("Value is a string:", value);  // "Value is a string: Hello"
15}

Typoperatoren werden verwendet, um den Typ eines Wertes zu überprüfen oder ihn in einen bestimmten Typ umzuwandeln.

• Der typeof-Operator gibt den Typ einer Variablen zurück.
• Der instanceof-Operator überprüft, ob ein Objekt zu einer bestimmten Klasse gehört.
• Der is-Operator wird verwendet, um zu überprüfen, ob ein Wert einen bestimmten Typ hat. Es ist Teil von TypeScripts Typwächtern.

Zusammenfassung

• Arithmetische Operatoren: Führen grundlegende Berechnungen durch.
• Zuweisungsoperatoren: Weisen Werte Variablen zu.
• Vergleichsoperatoren: Vergleichen Werte.
• Logische Operatoren: Kombinieren logische Bedingungen.
• Bitweise Operatoren: Führen Operationen auf Bit-Ebene durch.
• Ternärer Operator: Gibt Werte basierend auf Bedingungen zurück.
• Typoperatoren können den Typ eines Wertes überprüfen.

In TypeScript können diese Operatoren verwendet werden, um komplexe Berechnungen und bedingte Ausdrücke effizient zu schreiben.

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