Operatorer i TypeScript

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.

YouTube Video