TypeScript'te Operatörler
Bu makale, TypeScript'teki operatörleri açıklar.
YouTube Video
TypeScript'te Operatörler
TypeScript'teki operatörler, sayısal hesaplamalar, değer karşılaştırmaları ve mantıksal işlemler için kullanılır. TypeScript, JavaScript'e benzer operatörler kullandığı için alışması kolaydır, ancak TypeScript, tür güvenliği kullanarak daha titiz işlemlere olanak tanır.
Ana operatörler aşağıdaki gibidir:.
Aritmetik Operatörler
Aritmetik operatörler, sayısal hesaplamalar için kullanılır.
Operatör | Açıklama | Örnek | Sonuç |
---|---|---|---|
+ |
Toplama | 5 + 3 |
8 |
- |
Çıkarma | 5 - 3 |
2 |
* |
Çarpma | 5 * 3 |
15 |
/ |
Bölme | 5 / 2 |
2.5 |
% |
Kalan | 5 % 2 |
1 |
++ |
Artırma (prefix) | let x = 5; ++x |
6 |
-- |
Azaltma (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);
Atama Operatörleri
Atama operatörleri, sağdaki değeri soldaki değişkene atar.
Operatör | Açıklama | Örnek | Sonuç |
---|---|---|---|
= |
Atama | x = 10 |
x = 10 |
+= |
Topla ve ata | x += 5 |
x = 15 |
-= |
Çıkar ve ata | x -= 5 |
x = 5 |
*= |
Çarp ve ata | x *= 2 |
x = 20 |
/= |
Böl ve ata | x /= 2 |
x = 5 |
%= |
Kalanı bul ve ata | x %= 3 |
x = 1 |
1let z = 5;
2z += 3;
3console.log(z); // Outputs: 8
4
5z *= 2;
6console.log(z); // Outputs: 16
Karşılaştırma Operatörleri
Karşılaştırma operatörleri değerleri karşılaştırır ve true
veya false
döndürür.
Operatör | Açıklama | Örnek | Sonuç |
---|---|---|---|
== |
Eşit (tip karşılaştırması yok) | 5 == "5" |
true |
=== |
Sıkı eşit (tip karşılaştırması dahil) | 5 === "5" |
false |
!= |
Farklı (tip karşılaştırması yok) | 5 != "5" |
false |
!== |
Kesinlikle farklı (tip karşılaştırması dahil) | 5 !== "5" |
true |
> |
Büyük | 5 > 3 |
true |
< |
Küçük | 5 < 3 |
false |
>= |
Büyük veya eşit | 5 >= 5 |
true |
<= |
Küçük veya eşit | 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
Mantıksal Operatörler
Mantıksal operatörler, mantıksal ifadeleri birleştirmek için kullanılır.
Operatör | Açıklama | Örnek | Sonuç |
---|---|---|---|
&& |
Mantıksal VE | true && false |
false |
|| |
Mantıksal VEYA | true || false |
true |
! |
Olumsuzlama | !true |
false |
1console.log('true && false :', true && false); // Outputs: false
2console.log('true || false :', true || false); // Outputs: true
3console.log('!true :', !true); // Outputs: false
Mantıksal Operatörlerin Öncelik Sırası
TypeScript'te, mantıksal operatörler genellikle önce DEĞİL
(NOT
), ardından VE
(AND
) ve son olarak VEYA
(OR
) sırasına göre değerlendirilir.
NOT
En Yüksek Önceliğe Sahiptir
NOT
, bir unary operatördür ve en yüksek öncelikle değerlendirilir.
1console.log(!true || false); // false
AND
, OR
Üzerine Öncelik Alır
AND
, OR
'dan daha yüksek bir önceliğe sahiptir, bu nedenle AND
kısmı önce değerlendirilir.
1console.log(true || false && false); // true
Sonuç olarak, AND
(&&
) kısmı önce hesaplanır ve sonucu OR
(||
)'ye aktarılır.
AND
ve OR
Kısa Devre Değerlendirmesi Yapabilir
TypeScript'te, AND
ve OR
kısa devre değerlendirmesi yapar. Sonuç, sol taraftaki değerle belirlenirse, sağ taraftaki ifade değerlendirilmez.
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
Her iki durumda da, console.log()
çalıştırılmaz.
Önceliği Açıkça Belirlemek
Parantezler kullanarak ifadeleri açıkça gruplamak, öncelik konusunda yanlış anlamaları önleyebilir.
1console.log(true || (false && false)); // true
Doğal Dil ile Program Yorumlama Arasındaki Farklar
Mantıksal operatörleri kullanırken, doğal dildeki belirsizliklerin farkında olmak önemlidir. Örneğin, 'beyaz bir köpek veya bir kedi' ifadesi, 'beyaz bir köpek veya herhangi bir kedi' ya da 'beyaz bir köpek veya beyaz bir kedi' anlamına gelebilir. Kodda şu şekilde yazılabilir:.
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}
Doğal dil belirsiz olabileceğinden, kod yazarken ve sistemler tasarlarken dikkatli olmak gerekir.
Bit Düzeyi Operatörleri
Bit düzeyi operatörleri, sayıları bit düzeyinde işler.
Operatör | Açıklama | Örnek | Sonuç |
---|---|---|---|
& |
Mantıksal VE | 5 & 1 |
1 |
` | ` | Mantıksal VEYA | 5 | 1 |
^ |
Özel VEYA (XOR) | 5 ^ 1 |
4 |
~ |
Olumsuzlama (NOT) | ~5 |
-6 |
<< |
Sol Kaydırma | 5 << 1 |
10 |
>> |
Sağa Kaydırma (İmzalı) | 5 >> 1 |
2 |
>>> |
Sağa Kaydırma (İmzasız) | 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)
Üçlü Operatör
Üçlü operatör, bir koşullu ifadenin sonucuna bağlı olarak farklı değerler döndürür.
1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access); // Outputs: Allowed
Tür İşleçleri
TypeScript'in tür işleçleri şunları içerir:.
İşleç | Açıklama | Örnek | Sonuç |
---|---|---|---|
typeof |
Bir değişkenin türünü döndürür | typeof 123 |
"number" |
instanceof |
Bir nesnenin belirli bir sınıfa ait olup olmadığını kontrol eder | arr instanceof Array |
true |
is |
Bir tür koruyucu olarak, bir değerin belirli bir türe ait olup olmadığını kontrol eder | 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}
Tür işleçleri, bir değerin türünü kontrol etmek veya onu belirli bir türe dönüştürmek için kullanılır.
typeof
işleci bir değişkenin türünü döndürür.instanceof
işleci bir nesnenin belirli bir sınıfa ait olup olmadığını kontrol eder.is
işleci, bir değerin belirli bir türe ait olup olmadığını kontrol etmek için kullanılır. Bu, TypeScript'in tür koruyucularının bir parçasıdır.
Özet
- Aritmetik Operatörler: Temel hesaplamaları gerçekleştirir.
- Atama Operatörleri: Değişkenlere değerler atar.
- Karşılaştırma Operatörleri: Değerleri karşılaştırır.
- Mantıksal Operatörler: Mantıksal koşulları birleştirir.
- Bit Düzeyi Operatörler: Bit düzeyinde işlemler gerçekleştirir.
- Üçlü Operatör: Koşullara bağlı olarak değer döndürür.
- Tür işleçleri bir değerin türünü kontrol edebilir.
TypeScript'te bu operatörler, karmaşık hesaplamaları ve koşullu ifadeleri verimli bir şekilde yazmak için kullanılabilir.
Yukarıdaki makaleyi, YouTube kanalımızda Visual Studio Code'u kullanarak takip edebilirsiniz. Lütfen YouTube kanalını da kontrol edin.