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.