JavaScript'teki Operatörler

Bu makalede, JavaScript'teki operatörleri açıklayacağız.

YouTube Video

JavaScript'teki Operatörler

JavaScript'teki operatörler, sayılar ve değişkenler üzerinde hesaplama veya karşılaştırma yapmak için kullanılan semboller veya anahtar kelimelerdir. Farklı işlemleri gerçekleştiren çeşitli operatör türleri vardır. İşte başlıca operatörlerin bir özet listesi:.

Aritmetik Operatörler

JavaScript'ın aritmetik operatörleri şunları içerir:.

 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);

Aritmetik operatörler, sayılar üzerinde temel matematiksel işlemleri gerçekleştirir. Toplama ve çıkarmaya ek olarak, modül, artış ve azalış işlemlerini gerçekleştirebilirsiniz. Artış veya azalış operatörüyle döndürülen değerin, operatörün operandan önce mi yoksa sonra mı yerleştirildiğine bağlı olarak farklılık gösterdiğini unutmayın.

Atama Operatörleri

JavaScript'ın atama operatörleri şunları içerir:.

 1let x = 10;
 2
 3x += 5;  // x = x + 5, so x becomes 15
 4console.log('After x += 5 : ', x);  // 15
 5
 6x -= 10;
 7console.log('After x -= 10 : ', x);  // 5
 8
 9x *= 3;
10console.log('After x *= 3 : ', x);  // 15
11
12x /= 3;
13console.log('After x /= 3 : ', x);  // 5
14
15x %= 2;
16console.log('After x %= 2 : ', x);  // 1

Atama operatörleri, değişkenlere değer atamak veya değişkenlerin değerlerini güncellemek için kullanılır. Normal atamanın yanı sıra, toplama ve modülüs gibi aritmetik işlemler için de atama operatörleri vardır.

Karşılaştırma Operatörleri

JavaScript'ın karşılaştırma operatörleri şunları içerir:.

 1console.log("5 == '5' evaluates to:", 5 == "5");   // true (because the values are equal)
 2console.log("5 === '5' evaluates to:", 5 === "5"); // false (because the types are different)
 3console.log("5 != '5' evaluates to:", 5 != "5");   // false
 4console.log("5 !== '5' evaluates to:", 5 !== "5"); // true
 5console.log("5 > 2 evaluates to:", 5 > 2);         // true
 6console.log("5 < 2 evaluates to:", 5 < 2);         // false
 7console.log("5 >= 5 evaluates to:", 5 >= 5);       // true
 8console.log("5 <= 4 evaluates to:", 5 <= 4);       // false
 9console.log("5 >= '5' evaluates to:", 5 >= "5");   // true
10console.log("5 <= '5' evaluates to:", 5 <= "5");   // true

• Karşılaştırma operatörleri, değerleri karşılaştırır ve doğru (true) veya yanlış (false) döndürür.
• Eşitlik operatörü (==) karşılaştırmayı gerçekleştirmeden önce gerekli olduğunda farklı türleri otomatik olarak dönüştürür. Sıkı eşitlik operatörü (===) karşılaştırma sırasında herhangi bir tür dönüşümü yapmaz ve yalnızca her iki değerin aynı türe ve aynı değere sahip olması durumunda true döndürür. Sıkı eşitlik operatörünün (===) kullanılması, istenmeyen tür dönüşümlerinden kaynaklanan hataları önlemeye yardımcı olur, bu nedenle öncelikli olarak kullanılması tavsiye edilir.

Mantıksal Operatörler

JavaScript'ın mantıksal operatörleri şunları içerir:.

1let a = true;
2let b = false;
3
4console.log("a && b evaluates to:", a && b);  // false
5console.log("a || b evaluates to:", a || b);  // true
6console.log("!a evaluates to:", !a);          // false

Mantıksal operatörler, birden fazla koşul olduğunda koşulların kombinasyonlarını değerlendirmek için kullanılır.

Mantıksal Operatörlerin Önceliği

JavaScript'te, mantıksal operatörler genellikle sırasıyla önce DEĞİL (NOT), ardından VE (AND) ve son olarak VEYA (OR) değerlendirilir.

DEĞİL (NOT) en yüksek önceliğe sahiptir

DEĞİL (NOT) bir tekil operatördür ve en yüksek öncelikle değerlendirilir.

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

VE (AND) VEYA (OR) üzerinde önceliğe sahiptir

VE (AND) VEYA (OR) operatöründen daha yüksek önceliğe sahiptir, bu yüzden VE bölümü önce değerlendirilir.

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

Bu şekilde, AND (&&) kısmı önce değerlendirilir ve sonucu OR (||) kısmına iletilir.

VE (AND) ve VEYA (OR) kısa devre değerlendirmesi yapar

JavaScript'in VE (AND) ve VEYA (OR) operatörleri kısa devre değerlendirmesi yapar. Sonuç, sol taraftaki değerle belirlenebiliyorsa, sağ tarafındaki 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ılmayacaktır.

Açık bir öncelik belirleyin

Parantezlerle ifadeleri açıkça gruplandırarak öncelik sıralamasıyla ilgili yanlış anlamaların önüne geçebilirsiniz.

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

Doğal dil ve program yorumlaması arasındaki farklar

Mantıksal operatörler kullanılırken, doğal dildeki belirsizliklerin farkında olmak önemlidir. Örneğin, 'beyaz köpek ya da kedi' dediğinizde bu, 'beyaz bir köpek veya herhangi bir renkte kedi' ya da 'beyaz bir köpek veya beyaz bir kedi' anlamına gelebilir. Kodda, bu şekilde görünecektir:.

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}
8
9console.log(true || (false && false));  // true

Doğal dil bu tür belirsizlikler içerdiğinden, kod yazma veya tasarım yaparken dikkatli olunmalıdır.

Üçlü Operatör (Koşullu Operatör)

JavaScript, bir üçlü operatör (koşul operatörü) içerir.

1let age = 20;
2let message = age >= 18 ? "Adult" : "Minor";
3console.log(message);  // "Adult"

Bu, koşul ? doğruysa değer : yanlışsa değer şeklinde yazılır.

Bit Düzeyinde Operatörler

JavaScript bit düzeyindeki operatörler şunları içerir.

 1let x = 0x0F & 0x0C;
 2console.log("0x0F & 0x0C evaluates to:", x, "(0x0C, 12)");  // 0x0C (12)
 3
 4x = 0x04 | 0x02;
 5console.log("0x04 | 0x02 evaluates to:", x, "(0x06, 6)");  // 0x06 (6)
 6
 7x = 0x0F ^ 0x0C;
 8console.log("0x0F ^ 0x0C evaluates to:", x, "(0x03, 3)");  // 0x03 (3)
 9
10// The inverted number is represented as a negative value
11// because JavaScript numbers are stored as signed 32-bit integers.
12x = ~0x0C;
13console.log("~0x0C evaluates to:", x, "(-13, 0xF3)");  // 0xF3 (-13)
14
15x = 0x04 << 1;
16console.log("0x04 << 1 evaluates to:", x, "(0x08, 8)");    // 0x08 (8)
17x = 0x04 >> 1;
18console.log("0x04 >> 1 evaluates to:", x, "(0x02, 2)");    // 0x02 (2)

Bit operatörleri, sayılar üzerinde bit düzeyinde hesaplamalar yapar. Genellikle düşük seviyeli işlemler için kullanılırlar.

Tip Operatörleri

JavaScript tür operatörleri şunları içerir.

1console.log(typeof "Hello");  // "string"
2console.log(typeof 42);       // "number"
3
4let arr = [1, 2, 3];
5console.log("arr instanceof Array : ", arr instanceof Array); // true

Tip operatörleri, bir değerin tipini kontrol etmek veya belirli bir tipe dönüştürmek için kullanılır.

typeof operatörü, bir değişkenin türünü döndürür.

instanceof operatörü, bir nesnenin belirli bir sınıfa ait olup olmadığını kontrol eder.

Özet

• Aritmetik operatörler temel hesaplamalar yapar.
• Atama operatörleri, değişkenlere değer atar veya günceller.
• Karşılaştırma operatörleri, iki değeri karşılaştırır ve doğru ya da yanlış döndürür.
• Mantıksal operatörler, koşul kombinasyonlarını değerlendirir.
• Üçlü operatörler, koşul ifadelerini iften daha kısa bir biçimde yazmanıza olanak tanır.
• Bit düzeyindeki operatörler, bit düzeyinde hesaplamalar yapar.
• Tip operatörleri, bir değerin tipini kontrol etmenizi sağlar.

Yukarıdaki makaleyi, YouTube kanalımızda Visual Studio Code'u kullanarak takip edebilirsiniz. Lütfen YouTube kanalını da kontrol edin.

YouTube Video