Operatorer i TypeScript
Denne artikel forklarer operatorer i TypeScript.
YouTube Video
Operatorer i TypeScript
Operatorer i TypeScript bruges til at udføre numeriske beregninger, værdisammenligninger og logiske operationer. Da TypeScript bruger lignende operatorer som JavaScript, er de nemme at vænne sig til, men TypeScript tillader mere præcise operationer ved hjælp af type-sikkerhed.
De vigtigste operatorer er som følger:.
Aritmetiske operatorer
Aritmetiske operatorer bruges til numeriske beregninger.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
+ |
Addition | 5 + 3 |
8 |
- |
Subtraktion | 5 - 3 |
2 |
* |
Multiplikation | 5 * 3 |
15 |
/ |
Division | 5 / 2 |
2.5 |
% |
Rest | 5 % 2 |
1 |
++ |
Inkrement (prefix) | let x = 5; ++x |
6 |
-- |
Dekrement (prefix) | let x = 5; --x |
4 |
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);
Tildelingsoperatorer
Tildelingsoperatorer tilknytter værdien til højre til variablen til venstre.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
= |
Tildeling | x = 10 |
x = 10 |
+= |
Læg til og tildel | x += 5 |
x = 15 |
-= |
Træk fra og tildel | x -= 5 |
x = 5 |
*= |
Multiply og tildel | x *= 2 |
x = 20 |
/= |
Divider og tildel | x /= 2 |
x = 5 |
%= |
Rest og tildel | x %= 3 |
x = 1 |
1let z = 5;
2z += 3;
3console.log(z); // Outputs: 8
4
5z *= 2;
6console.log(z); // Outputs: 16
Sammenligningsoperatorer
Sammenligningsoperatorer sammenligner værdier og returnerer true
eller false
.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
== |
Lige (ingen type-sammenligning) | 5 == "5" |
true |
=== |
Strikt lige (inkluderer type) | 5 === "5" |
false |
!= |
Ikke lige (ingen type-sammenligning) | 5 != "5" |
false |
!== |
Strengt ikke lige (inkluderer type) | 5 !== "5" |
true |
> |
Større end | 5 > 3 |
true |
< |
Mindre end | 5 < 3 |
false |
>= |
Større end eller lig med | 5 >= 5 |
true |
<= |
Mindre end eller lig med | 5 <= 3 |
false |
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
Logiske operatorer
Logiske operatorer bruges til at kombinere logiske udtryk.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
&& |
Logisk OG | true && false |
false |
|| |
Logisk ELLER | true || false |
true |
! |
Negation | !true |
false |
1console.log('true && false :', true && false); // Outputs: false
2console.log('true || false :', true || false); // Outputs: true
3console.log('!true :', !true); // Outputs: false
Forrang for logiske operatører
I TypeScript evalueres logiske operatorer normalt i rækkefølgen NOT
først, efterfulgt af AND
og til sidst OR
.
NOT
har den højeste forrang
NOT
er en unær operator og evalueres med den højeste forrang.
1console.log(!true || false); // false
AND
har forrang over OR
AND
har højere forrang end OR
, så AND
-delen evalueres først.
1console.log(true || false && false); // true
Som resultat beregnes AND
-delen (&&
) først, og dens resultat overføres til OR
(||
).
AND
og OR
udfører kortslutningsevaluering
I TypeScript udfører AND
og OR
kortslutningsevaluering. Hvis resultatet afgøres af den venstre værdi, evalueres det højre udtryk ikke.
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
I begge tilfælde udføres console.log()
ikke.
Eksplicit definition af forrang
Brug af parenteser til eksplicit gruppering af udtryk kan forhindre misforståelser om forrang.
1console.log(true || (false && false)); // true
Forskelle mellem naturligt sprog og programfortolkning
Når man bruger logiske operatorer, er det vigtigt at være opmærksom på tvetydigheder i naturligt sprog. For eksempel i sætningen 'en hvid hund eller en kat' kan det betyde enten 'en hvid hund eller hvilken som helst kat' eller 'en hvid hund eller en hvid kat.'. I kode kan det skrives som følger:.
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 naturligt sprog kan være tvetydigt, kræves forsigtighed, når man koder og designer systemer.
Bitvise operatorer
Bitvise operatorer manipulerer tal på bitniveau.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
& |
Logisk OG | 5 & 1 |
1 |
` | ` | Logisk ELLER | 5 | 1 |
^ |
Eksklusiv ELLER (XOR) | 5 ^ 1 |
4 |
~ |
Negation (IKKE) | ~5 |
-6 |
<< |
Venstreforskydning | 5 << 1 |
10 |
>> |
Højreforskydning (med fortegn) | 5 >> 1 |
2 |
>>> |
Højreforskydning (uden fortegn) | 5 >>> 1 |
2 |
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ær Operator
Den ternære operator returnerer forskellige værdier baseret på resultatet af et betinget udtryk.
1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access); // Outputs: Allowed
Typeoperatorer
TypeScripts typeoperatorer inkluderer følgende:.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
typeof |
Returnerer typen af en variabel | typeof 123 |
"number" |
instanceof |
Kontrollerer, om et objekt tilhører en specifik klasse | arr instanceof Array |
true |
is |
Som en typebeskytter kontrollerer den, om en værdi er af en specifik type | value is string |
true or false |
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}
Typeoperatorer bruges til at kontrollere typen af en værdi eller konvertere den til en specifik type.
typeof
-operatoren returnerer typen af en variabel.instanceof
-operatoren kontrollerer, om et objekt tilhører en specifik klasse.is
-operatoren bruges til at kontrollere, om en værdi er af en specifik type. Den er en del af TypeScripts typebeskyttere.
Sammendrag
- Aritmetiske Operatorer: Udfører grundlæggende beregninger.
- Tildelingsoperatorer: Tildeler værdier til variabler.
- Sammenligningsoperatorer: Sammenligner værdier.
- Logiske Operatorer: Kombinerer logiske betingelser.
- Bitvise Operatorer: Udfører operationer på bitniveau.
- Ternær Operator: Returnerer værdier baseret på betingelser.
- Typeoperatorer kan kontrollere en værdis type.
I TypeScript kan disse operatorer bruges til effektivt at skrive komplekse beregninger og betingede udtryk.
Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.