Operatorer i TypeScript
Denne artikkelen forklarer operatorer i TypeScript.
YouTube Video
Operatorer i TypeScript
Operatorer i TypeScript brukes til å utføre numeriske beregninger, verdikomparasjoner og logiske operasjoner. Siden TypeScript bruker lignende operatorer som JavaScript, er de enkle å bli vant til, men TypeScript tillater strengere operasjoner ved å bruke typesikkerhet.
De viktigste operatorene er som følger:.
Aritmetiske operatorer
Aritmetiske operatorer brukes til numeriske beregninger.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
+ |
Addisjon | 5 + 3 |
8 |
- |
Subtraksjon | 5 - 3 |
2 |
* |
Multiplikasjon | 5 * 3 |
15 |
/ |
Divisjon | 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 tildeler verdien til høyre til variabelen til venstre.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
= |
Tildeling | x = 10 |
x = 10 |
+= |
Legg til og tildel | x += 5 |
x = 15 |
-= |
Trekk fra og tildel | x -= 5 |
x = 5 |
*= |
Multipliser 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 verdier og returnerer true
eller false
.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
== |
Lik (ingen typesammenligning) | 5 == "5" |
true |
=== |
Strengt lik (inkluderer type) | 5 === "5" |
false |
!= |
Ikke lik (ingen typesammenligning) | 5 != "5" |
false |
!== |
Strengt ulik (inkluderer type) | 5 !== "5" |
true |
> |
Større enn | 5 > 3 |
true |
< |
Mindre enn | 5 < 3 |
false |
>= |
Større enn eller lik | 5 >= 5 |
true |
<= |
Mindre enn eller lik | 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 brukes til å kombinere logiske uttrykk.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
&& |
Logisk OG | true && false |
false |
|| |
Logisk ELLER | true || false |
true |
! |
Negasjon | !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 operatorer
I TypeScript blir logiske operatorer vanligvis evaluert i rekkefølgen NOT
først, etterfulgt av AND
, og til slutt OR
.
NOT
Har høyest forrang
NOT
er en unær operator og evalueres med høyest forrang.
1console.log(!true || false); // false
AND
Har høyere forrang enn OR
AND
har høyere forrang enn OR
, så AND
-delen evalueres først.
1console.log(true || false && false); // true
Som et resultat blir AND
(&&
)-delen beregnet først, og resultatet sendes videre til OR
(||
).
AND
og OR
Utfører kortslutningsvurdering
I TypeScript utfører AND
og OR
kortslutningsvurdering. Hvis resultatet bestemmes av venstre verdi, blir ikke høyre uttrykk evaluert.
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 tilfeller blir ikke console.log()
utført.
Spesifisere Forrang Eksplicit
Å bruke parenteser for å gruppere uttrykk eksplisitt kan forhindre misforståelser om forrang.
1console.log(true || (false && false)); // true
Forskjeller Mellom Naturlig Språk og Programmeringsforståelse
Når man bruker logiske operatorer, er det viktig å være klar over tvetydigheter i naturlig språk. For eksempel, i uttrykket 'en hvit hund eller en katt', kan det bety enten 'en hvit hund eller hvilken som helst katt' eller 'en hvit hund eller en hvit katt'. I kode kan det skrives slik:.
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}
Siden naturlig språk kan være tvetydig, kreves forsiktighet når man koder og designer systemer.
Bitvise operatorer
Bitvise operatorer manipulerer tall på bitnivå.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
& |
Logisk OG | 5 & 1 |
1 |
` | ` | Logisk ELLER | 5 | 1 |
^ |
Eksklusiv ELLER (XOR) | 5 ^ 1 |
4 |
~ |
Negasjon (IKKE) | ~5 |
-6 |
<< |
Venstreforskyvning | 5 << 1 |
10 |
>> |
Høyreforskyvning (med fortegn) | 5 >> 1 |
2 |
>>> |
Høyreforskyvning (uten 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 operatoren returnerer forskjellige verdier basert på resultatet av et betinget uttrykk.
1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access); // Outputs: Allowed
Typeoperatører
TypeScripts typeoperatører inkluderer følgende:.
Operator | Beskrivelse | Eksempel | Resultat |
---|---|---|---|
typeof |
Returnerer typen til en variabel | typeof 123 |
"number" |
instanceof |
Sjekker om et objekt tilhører en spesifikk klasse | arr instanceof Array |
true |
is |
Som en typebeskyttelse, sjekker om en verdi er av en spesifikk 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}
Typeoperatører brukes til å sjekke typen til en verdi eller konvertere den til en spesifikk type.
typeof
-operatoren returnerer typen til en variabel.instanceof
-operatoren sjekker om et objekt tilhører en spesifikk klasse.is
-operatoren brukes til å sjekke om en verdi er av en spesifikk type. Den er en del av TypeScripts typebeskyttelser.
Sammendrag
- Aritmetiske operatorer: Utfører grunnleggende beregninger.
- Tildelingsoperatorer: Tildeler verdier til variabler.
- Sammenligningsoperatorer: Sammenligner verdier.
- Logiske operatorer: Kombinerer logiske betingelser.
- Bitvise operatorer: Utfører operasjoner på bitnivå.
- Ternær operator: Returnerer verdier basert på betingelser.
- Typeoperatører kan sjekke typen til en verdi.
I TypeScript kan disse operatorene brukes til å skrive komplekse beregninger og betingede uttrykk effektivt.
Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.