Operatorer i TypeScript

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.

YouTube Video