Operatoren in TypeScript

Dit artikel legt de operatoren in TypeScript uit.

YouTube Video

Operatoren in TypeScript

Operatoren in TypeScript worden gebruikt om numerieke berekeningen, waardevergelijkingen en logische bewerkingen uit te voeren. Aangezien TypeScript vergelijkbare operatoren als JavaScript gebruikt, zijn ze gemakkelijk te leren, maar TypeScript biedt strengere bewerkingen met behulp van typeveiligheid.

De belangrijkste operatoren zijn als volgt:.

Aritmetische operatoren

Aritmetische operatoren worden gebruikt voor numerieke berekeningen.

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

Toekenningsoperatoren

Toekenningsoperatoren wijzen de waarde rechts toe aan de variabele links.

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

Vergelijkingsoperatoren

Vergelijkingsoperatoren vergelijken waarden en geven true of false terug.

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 worden gebruikt om logische expressies te combineren.

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

Voorrang van logische operatoren

In TypeScript worden logische operatoren meestal geëvalueerd in de volgorde NIET eerst, gevolgd door EN en tot slot OF.

NIET Heeft de Hoogste Voorrang

NIET is een unitaire operator en wordt geëvalueerd met de hoogste voorrang.

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

EN Heeft Voorrang op OF

EN heeft een hogere voorrang dan OF, dus het EN-gedeelte wordt eerst geëvalueerd.

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

Als gevolg hiervan wordt het EN (&&)-gedeelte eerst berekend, en het resultaat wordt doorgegeven aan OF (||).

EN en OF Voeren Short-Circuit Evaluatie uit

In TypeScript voeren EN en OF short-circuit evaluatie uit. Als het resultaat wordt bepaald door de linkerwaarde, wordt de rechterexpressie niet geëvalueerd.

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 beide gevallen wordt console.log() niet uitgevoerd.

Voorrang Expliciet Definiëren

Het gebruik van haakjes om expressies expliciet te groeperen kan misverstanden over voorrang voorkomen.

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

Verschillen Tussen Natuurlijke Taal en Programmainterpretatie

Bij het gebruik van logische operatoren is het belangrijk om je bewust te zijn van ambiguïteiten in natuurlijke taal. Bijvoorbeeld, in de zin 'een witte hond of een kat,' kan het betekenen 'een witte hond of welke kat dan ook' of 'een witte hond of een witte kat.'. In code kan het als volgt worden geschreven:.

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}

Omdat natuurlijke taal dubbelzinnig kan zijn, is voorzichtigheid geboden bij het coderen en ontwerpen van systemen.

Bitwise-operatoren

Bitwise-operatoren manipuleren getallen op bitniveau.

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)

Ternaire Operator

De ternaire operator retourneert verschillende waarden afhankelijk van het resultaat van een voorwaardelijke expressie.

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

Type-operatoren

De type-operatoren van TypeScript omvatten de volgende:.

 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}

Type-operatoren worden gebruikt om het type van een waarde te controleren of om te zetten naar een specifiek type.

• De typeof-operator retourneert het type van een variabele.
• De instanceof-operator controleert of een object tot een specifieke klasse behoort.
• De is-operator wordt gebruikt om te controleren of een waarde van een specifiek type is. Het maakt deel uit van de typebewakers van TypeScript.

Samenvatting

• Aritmetische Operatoren: Voeren basisberekeningen uit.
• Toewijzingsoperatoren: Ken waarden toe aan variabelen.
• Vergelijkingsoperatoren: Vergelijken waarden.
• Logische Operatoren: Combineren logische voorwaarden.
• Bitwise Operatoren: Voeren bewerkingen uit op bitniveau.
• Ternaire Operator: Retourneert waarden op basis van voorwaarden.
• Type-operatoren kunnen het type van een waarde controleren.

In TypeScript kunnen deze operatoren worden gebruikt om complexe berekeningen en conditionele expressies efficiënt te schrijven.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video