Operatorer i TypeScript
Den här artikeln förklarar operatorer i TypeScript.
YouTube Video
Operatorer i TypeScript
Operatorer i TypeScript används för att utföra numeriska beräkningar, värdejämförelser och logiska operationer. Eftersom TypeScript använder liknande operatorer som JavaScript är de lätta att vänja sig vid, men TypeScript tillåter mer rigorösa operationer med hjälp av typkontroll.
De huvudsakliga operatorerna är följande:.
Aritmetiska operatorer
Aritmetiska operatorer används för numeriska beräkningar.
Operator | Beskrivning | Exempel | Resultat |
---|---|---|---|
+ |
Addition | 5 + 3 |
8 |
- |
Subtraktion | 5 - 3 |
2 |
* |
Multiplikation | 5 * 3 |
15 |
/ |
Division | 5 / 2 |
2.5 |
% |
Rest | 5 % 2 |
1 |
++ |
Inkrementering (prefix) | let x = 5; ++x |
6 |
-- |
Dekrementering (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);
Tilldelningsoperatorer
Tilldelningsoperatorer tilldelar värdet till höger till variabeln till vänster.
Operator | Beskrivning | Exempel | Resultat |
---|---|---|---|
= |
Tilldelning | x = 10 |
x = 10 |
+= |
Addera och tilldela | x += 5 |
x = 15 |
-= |
Subtrahera och tilldela | x -= 5 |
x = 5 |
*= |
Multiplicera och tilldela | x *= 2 |
x = 20 |
/= |
Dividera och tilldela | x /= 2 |
x = 5 |
%= |
Rest och tilldela | x %= 3 |
x = 1 |
1let z = 5;
2z += 3;
3console.log(z); // Outputs: 8
4
5z *= 2;
6console.log(z); // Outputs: 16
Jämförelseoperatorer
Jämförelseoperatorer jämför värden och returnerar true
eller false
.
Operator | Beskrivning | Exempel | Resultat |
---|---|---|---|
== |
Lika (ingen typjämförelse) | 5 == "5" |
true |
=== |
Exakt lika (inkluderar typ) | 5 === "5" |
false |
!= |
Inte lika (ingen typjämförelse) | 5 != "5" |
false |
!== |
Exakt inte lika (inkluderar typ) | 5 !== "5" |
true |
> |
Större än | 5 > 3 |
true |
< |
Mindre än | 5 < 3 |
false |
>= |
Större än eller lika med | 5 >= 5 |
true |
<= |
Mindre än eller lika 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
Logiska operatorer
Logiska operatorer används för att kombinera logiska uttryck.
Operator | Beskrivning | Exempel | Resultat |
---|---|---|---|
&& |
Logisk OCH | 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
Prioritet för logiska operatorer
I TypeScript utvärderas logiska operatorer vanligtvis i ordningen NOT
först, följt av AND
och slutligen OR
.
NOT
har högst prioritet
NOT
är en unär operator och utvärderas med högst prioritet.
1console.log(!true || false); // false
AND
har högre prioritet än OR
AND
har högre prioritet än OR
, så AND
-delen utvärderas först.
1console.log(true || false && false); // true
Som ett resultat beräknas AND
(&&
)-delen först, och dess resultat skickas vidare till OR
(||
).
AND
och OR
använder kortslutningsutvärdering
I TypeScript använder AND
och OR
kortslutningsutvärdering. Om resultatet bestäms av värdet på den vänstra sidan utvärderas inte uttrycket på den högra sidan.
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 båda fallen körs inte console.log()
.
Att explicit definiera prioritet
Att använda parenteser för att explicit gruppera uttryck kan förhindra missförstånd om prioritet.
1console.log(true || (false && false)); // true
Skillnader mellan naturligt språk och programtolkning
När du använder logiska operatorer är det viktigt att vara medveten om tvetydigheter i naturligt språk. Till exempel, i frasen 'en vit hund eller en katt' kan det antingen betyda 'en vit hund eller vilken katt som helst' eller 'en vit hund eller en vit katt.'. I kod kan det skrivas som följer:.
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}
Eftersom naturligt språk kan vara tvetydigt krävs försiktighet vid kodning och systemdesign.
Bitvisa operatorer
Bitvisa operatorer manipulerar tal på bitnivå.
Operator | Beskrivning | Exempel | Resultat |
---|---|---|---|
& |
Logisk OCH | 5 & 1 |
1 |
` | ` | Logisk ELLER | 5 | 1 |
^ |
Exklusivt ELLER (XOR) | 5 ^ 1 |
4 |
~ |
Negation (NOT) | ~5 |
-6 |
<< |
Vänsterskift | 5 << 1 |
10 |
>> |
Högerskift (Signerat) | 5 >> 1 |
2 |
>>> |
Högerskift (Osignerat) | 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
Ternär operator returnerar olika värden baserat på resultatet av ett villkorsuttryck.
1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access); // Outputs: Allowed
Typoperatorer
TypeScripts typoperatorer inkluderar följande:.
Operator | Beskrivning | Exempel | Resultat |
---|---|---|---|
typeof |
Returnerar typen av en variabel | typeof 123 |
"number" |
instanceof |
Kontrollerar om ett objekt tillhör en specifik klass | arr instanceof Array |
true |
is |
Som en typvakt kontrollerar den om ett värde är av en specifik typ | 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}
Typoperatorer används för att kontrollera typen av ett värde eller konvertera det till en specifik typ.
typeof
-operatorn returnerar typen av en variabel.instanceof
-operatorn kontrollerar om ett objekt tillhör en specifik klass.is
-operatorn används för att kontrollera om ett värde är av en specifik typ. Det är en del av TypeScripts typvakter.
Sammanfattning
- Aritmetiska operatorer: Utför grundläggande beräkningar.
- Tilldelningsoperatorer: Tilldelar värden till variabler.
- Jämförelseoperatorer: Jämför värden.
- Logiska operatorer: Kombinerar logiska villkor.
- Bitvisa operatorer: Utför operationer på bitnivå.
- Ternär operator: Returnerar värden baserat på villkor.
- Typoperatorer kan kontrollera typen av ett värde.
I TypeScript kan dessa operatorer användas för att skriva komplexa beräkningar och villkorsuttryck effektivt.
Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.