Operatory w TypeScript

Operatory w TypeScript

Ten artykuł wyjaśnia operatory w TypeScript.

YouTube Video

Operatory w TypeScript

Operatory w TypeScript są wykorzystywane do wykonywania obliczeń numerycznych, porównywania wartości i operacji logicznych. Ponieważ TypeScript korzysta z podobnych operatorów jak JavaScript, łatwo się do nich przyzwyczaić, ale TypeScript umożliwia bardziej rygorystyczne operacje dzięki bezpieczeństwu typów.

Główne operatory są następujące:.

Operatory Arytmetyczne

Operatory arytmetyczne są używane do obliczeń numerycznych.

Operator Opis Przykład Wynik
+ Dodawanie 5 + 3 8
- Odejmowanie 5 - 3 2
* Mnożenie 5 * 3 15
/ Dzielenie 5 / 2 2.5
% Reszta z dzielenia 5 % 2 1
++ Inkrementacja (prefiks) let x = 5; ++x 6
-- Dekrementacja (prefiks) 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);

Operatory Przypisania

Operatory przypisania przypisują wartość z prawej strony do zmiennej po lewej stronie.

Operator Opis Przykład Wynik
= Przypisanie x = 10 x = 10
+= Dodaj i przypisz x += 5 x = 15
-= Odejmij i przypisz x -= 5 x = 5
*= Pomnóż i przypisz x *= 2 x = 20
/= Podziel i przypisz x /= 2 x = 5
%= Reszta i przypisz x %= 3 x = 1
1let z = 5;
2z += 3;
3console.log(z);  // Outputs: 8
4
5z *= 2;
6console.log(z);  // Outputs: 16

Operatory Porównania

Operatory porównania porównują wartości i zwracają true lub false.

Operator Opis Przykład Wynik
== Równe (bez porównania typów) 5 == "5" true
=== Ściśle równe (z porównaniem typów) 5 === "5" false
!= Nierówne (bez porównania typów) 5 != "5" false
!== Ściśle nierówne (z porównaniem typów) 5 !== "5" true
> Większe niż 5 > 3 true
< Mniejsze niż 5 < 3 false
>= Większe lub równe 5 >= 5 true
<= Mniejsze lub równe 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

Operatory Logiczne

Operatory logiczne służą do łączenia wyrażeń logicznych.

Operator Opis Przykład Wynik
&& Logiczne AND true && false false
|| Logiczne OR true || false true
! Negacja !true false
1console.log('true && false :', true && false);  // Outputs: false
2console.log('true || false :', true || false);  // Outputs: true
3console.log('!true         :', !true);          // Outputs: false

Priorytet operatorów logicznych

W TypeScript operatory logiczne są zwykle oceniane w kolejności: najpierw NOT, następnie AND, a na końcu OR.

NOT ma najwyższy priorytet

NOT jest operatorem unarnym i jest oceniany z najwyższym priorytetem.

1console.log(!true || false);  // false
AND ma wyższy priorytet niż OR

AND ma wyższy priorytet niż OR, więc część AND jest oceniana jako pierwsza.

1console.log(true || false && false);  // true

W rezultacie najpierw obliczana jest część AND (&&), a jej wynik jest przekazywany do OR (||).

AND i OR wykonują ocenę krótkocyrkuitową

W TypeScript operatory AND i OR wykonują ocenę krótkocyrkuitową. Jeśli wynik jest określony na podstawie wartości po lewej stronie, wyrażenie po prawej stronie nie jest oceniane.

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

W obu przypadkach funkcja console.log() nie jest wykonywana.

Wyraźne definiowanie priorytetu

Używanie nawiasów do wyraźnego grupowania wyrażeń może zapobiec nieporozumieniom dotyczącym priorytetu.

1console.log(true || (false && false));  // true
Różnice między językiem naturalnym a interpretacją w programie

Podczas używania operatorów logicznych ważne jest, aby być świadomym niejednoznaczności języka naturalnego. Na przykład w wyrażeniu „biały pies lub kot” może to oznaczać „biały pies lub dowolny kot” lub „biały pies lub biały kot”. W kodzie można to zapisać w następujący sposób:.

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}

Ponieważ język naturalny może być niejednoznaczny, konieczna jest ostrożność przy kodowaniu i projektowaniu systemów.

Operatory Bitowe

Operatory bitowe manipulują liczbami na poziomie bitowym.

Operator Opis Przykład Wynik
& Logiczne AND 5 & 1 1
` ` Logiczne OR 5 | 1
^ Wyłączny OR (XOR) 5 ^ 1 4
~ Negacja (NOT) ~5 -6
<< Przesunięcie w Lewo 5 << 1 10
>> Przesunięcie w Prawo (ze Znakiem) 5 >> 1 2
>>> Przesunięcie w Prawo (bez Znaku) 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)

Operator warunkowy (ternary)

Operator warunkowy zwraca różne wartości w zależności od wyniku wyrażenia warunkowego.

1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access);  // Outputs: Allowed

Operatory Typów

Operatory typów w TypeScript obejmują następujące przypadki:.

Operator Opis Przykład Wynik
typeof Zwraca typ zmiennej typeof 123 "number"
instanceof Sprawdza, czy obiekt należy do określonej klasy arr instanceof Array true
is Jako strażnik typu sprawdza, czy wartość ma określony 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}

Operatory typów są używane do sprawdzania typu wartości lub ich konwersji na określony typ.

  • Operator typeof zwraca typ zmiennej.
  • Operator instanceof sprawdza, czy obiekt należy do określonej klasy.
  • Operator is jest używany do sprawdzania, czy wartość ma określony typ. Jest to część strażników typu w TypeScript.

Podsumowanie

  • Operatory arytmetyczne: Wykonują podstawowe obliczenia.
  • Operatory przypisania: Przypisują wartości do zmiennych.
  • Operatory porównania: Porównują wartości.
  • Operatory logiczne: Łączą warunki logiczne.
  • Operatory bitowe: Wykonują operacje na poziomie bitów.
  • Operator warunkowy (ternary): Zwraca wartości na podstawie warunków.
  • Operatory typów mogą sprawdzić typ wartości.

W TypeScript można używać tych operatorów do efektywnego pisania złożonych obliczeń i wyrażeń warunkowych.

Możesz śledzić ten artykuł, korzystając z Visual Studio Code na naszym kanale YouTube. Proszę również sprawdzić nasz kanał YouTube.

YouTube Video