JavaScript'te Operatörler Nasıl Kullanılır? 👨‍💻 En Çok Kullanılan Operatörler!

Giriş

JavaScript'te, veriler üzerinde işlem yapmak ve değerler üretmek için operatörleri kullanırız. Operatörler, değişkenler ve değerlerle birleşerek ifadeleri (expressions) oluşturur. Bu derste, JavaScript'teki temel operatör türlerini ve ifadelerin nasıl çalıştığını öğreneceğiz.

Operatörler, programlamanın temel yapı taşlarından biridir. Değişkenlere değer atamak, matematiksel hesaplamalar yapmak, değerleri karşılaştırmak ve mantıksal kararlar vermek için operatörlere ihtiyaç duyarız. İfadeler ise, bir değer üreten kod parçalarıdır ve genellikle operatörler ve operandlardan (operatörlerin üzerinde işlem yaptığı değerler) oluşur.

Aritmetik Operatörler

Aritmetik operatörler, matematiksel hesaplamalar yapmak için kullanılır. Temel aritmetik operatörler şunlardır:

• Toplama (+): İki sayıyı toplar.
• Çıkarma (-): Bir sayıdan diğerini çıkarır.
• Çarpma (*): İki sayıyı çarpar.
• Bölme (/): Bir sayıyı diğerine böler.
• Mod Alma (%): Bir sayının diğerine bölümünden kalanı verir.
• Artırma (++): Bir sayının değerini 1 artırır.
• Azaltma (--): Bir sayının değerini 1 azaltır.
• Üs Alma (**): Bir sayının üssünü alır (ES6+).

let sayi1 = 10;
let sayi2 = 5;

let toplam = sayi1 + sayi2; // 15
let fark = sayi1 - sayi2;   // 5
let carpim = sayi1 * sayi2; // 50
let bolum = sayi1 / sayi2;   // 2
let mod = sayi1 % 3;       // 1 (10'un 3'e bölümünden kalan)

let sayac = 0;
sayac++; // sayac şimdi 1
sayac--; // sayac şimdi 0

let us = 2 ** 3; // 8 (2 üzeri 3)

console.log("Toplam:", toplam);
console.log("Fark:", fark);
console.log("Çarpım:", carpim);
console.log("Bölüm:", bolum);
console.log("Mod:", mod);
console.log("Sayaç:", sayac);
console.log("Üs:", us);

Atama Operatörleri

Atama operatörleri, değişkenlere değer atamak için kullanılır. En temel atama operatörü eşittir (=) işaretidir. Ayrıca, aritmetik işlemleri atama ile birleştiren bileşik atama operatörleri de vardır:

• Atama (=): Sağdaki değeri soldaki değişkene atar.
• Toplayarak Atama (+=): Soldaki değişkenin değerine sağdaki değeri ekler ve sonucu soldaki değişkene atar.
• Çıkararak Atama (-=): Soldaki değişkenin değerinden sağdaki değeri çıkarır ve sonucu soldaki değişkene atar.
• Çarparak Atama (*=): Soldaki değişkenin değerini sağdaki değerle çarpar ve sonucu soldaki değişkene atar.
• Bölerek Atama (/=): Soldaki değişkenin değerini sağdaki değere böler ve sonucu soldaki değişkene atar.
• Mod Alarak Atama (%=): Soldaki değişkenin değerinin sağdaki değere bölümünden kalanı alır ve sonucu soldaki değişkene atar.
• Üs Alarak Atama (**=): Soldaki değişkenin değerinin üssünü sağdaki değere göre alır ve sonucu soldaki değişkene atar (ES6+).

let x = 10;
let y = 5;

x += y; // x = x + y;  x şimdi 15
console.log("x += y:", x);

x -= y; // x = x - y;  x şimdi 10 (15 - 5)
console.log("x -= y:", x);

x *= y; // x = x * y;  x şimdi 50 (10 * 5)
console.log("x *= y:", x);

x /= y; // x = x / y;  x şimdi 10 (50 / 5)
console.log("x /= y:", x);

x %= 3; // x = x % 3;  x şimdi 1 (10 % 3)
console.log("x %= 3:", x);

let z = 2;
z **= 3; // z = z ** 3; z şimdi 8 (2 ** 3)
console.log("z **= 3:", z);

Karşılaştırma Operatörleri

Karşılaştırma operatörleri, iki değeri karşılaştırmak ve sonuç olarak bir boolean (true veya false) değer döndürmek için kullanılır. Bu operatörler, genellikle koşullu ifadelerde (bir sonraki derste göreceğiz) kullanılır.

• Eşit (==): İki değerin eşit olup olmadığını kontrol eder (tip dönüşümü yapar).
• Eşit Değil (!=): İki değerin eşit olmadığını kontrol eder (tip dönüşümü yapar).
• Katı Eşit (===): İki değerin hem değer hem de tip olarak eşit olup olmadığını kontrol eder (tip dönüşümü yapmaz).
• Katı Eşit Değil (!==): İki değerin değer veya tip olarak eşit olmadığını kontrol eder (tip dönüşümü yapmaz).
• Büyük (>): Soldaki değerin sağdaki değerden büyük olup olmadığını kontrol eder.
• Küçük (<): Soldaki değerin sağdaki değerden küçük olup olmadığını kontrol eder.
• Büyük veya Eşit (>=): Soldaki değerin sağdaki değerden büyük veya eşit olup olmadığını kontrol eder.
• Küçük veya Eşit (<=): Soldaki değerin sağdaki değerden küçük veya eşit olup olmadığını kontrol eder.

let a = 10;
let b = 5;
let c = "10";

console.log("a == b:", a == b);   // false
console.log("a != b:", a != b);   // true
console.log("a == c:", a == c);   // true (tip dönüşümü yapıldı)
console.log("a === c:", a === c); // false (tipler farklı: number ve string)
console.log("a !== c:", a !== c); // true

console.log("a > b:", a > b);     // true
console.log("a < b:", a < b);     // false
console.log("a >= 10:", a >= 10); // true
console.log("b <= 5:", b <= 5);   // true

Mantıksal Operatörler

Mantıksal operatörler, boolean değerler üzerinde mantıksal işlemler yapmak için kullanılır. Genellikle birden fazla koşulu birleştirmek için kullanılırlar.

• Mantıksal VE (&&): Her iki koşul da true ise true döndürür.
• Mantıksal VEYA (||): Koşullardan en az biri true ise true döndürür.
• Mantıksal DEĞİL (!): Bir boolean değerin tersini alır (true ise false, false ise true yapar).

let yas = 25;
let ehliyetVar = true;

// Hem 18 yaşından büyük hem de ehliyeti var mı?
let arabaKullanabilir = (yas >= 18) && ehliyetVar;
console.log("Araba Kullanabilir mi?", arabaKullanabilir); // true

let haftasonu = true;
let havaGuzel = false;

// Haftasonu mu VEYA hava güzel mi?
let disariCik = haftasonu || havaGuzel;
console.log("Dışarı Çıkmalı mı?", disariCik); // true

let uyuyor = false;

// Uyumuyor mu?
let uyanik = !uyuyor;
console.log("Uyanık mı?", uyanik); // true

Diğer Operatörler

Yukarıda bahsedilen temel operatörlerin yanı sıra, JavaScript'te başka operatörler de bulunur:

• Koşul Operatörü (Ternary Operator) (? :): Üç operand alan tek operatördür. Bir koşulu değerlendirir ve koşul doğruysa bir değeri, yanlışsa başka bir değeri döndürür. koşul ? deger_dogruysa : deger_yanlissa şeklinde kullanılır.
• typeof Operatörü: Bir değişkenin veya ifadenin veri tipini string olarak döndürür.
• instanceof Operatörü: Bir nesnenin belirli bir sınıfın örneği olup olmadığını kontrol eder.
• delete Operatörü: Bir nesnenin özelliğini siler.
• in Operatörü: Belirtilen özelliğin bir nesnede olup olmadığını kontrol eder.
• Virgül Operatörü (,): Birden fazla ifadeyi tek bir ifadede birleştirmek için kullanılır. Genellikle for döngülerinde kullanılır.

// Koşul Operatörü
let puan = 75;
let sonuc = (puan >= 50) ? "Geçti" : "Kaldı";
console.log("Sonuç:", sonuc); // Geçti

// typeof Operatörü
let isim = "Ali";
let sayi = 123;
let dogruMu = true;
console.log("isim tipi:", typeof isim);     // string
console.log("sayi tipi:", typeof sayi);     // number
console.log("dogruMu tipi:", typeof dogruMu); // boolean
console.log("tanimsiz tipi:", typeof tanimsizDegisken); // undefined

// instanceof Operatörü (Nesneler konusunda daha detaylı görülecek)
let dizi = [1, 2, 3];
console.log("dizi Array mi?", dizi instanceof Array); // true

// delete Operatörü (Nesneler konusunda daha detaylı görülecek)
let araba = { marka: "Toyota", model: "Corolla" };
console.log("Araba (önce):", araba);
delete araba.model;
console.log("Araba (sonra):", araba);

// in Operatörü (Nesneler konusunda daha detaylı görülecek)
console.log("'marka' arabada var mı?", 'marka' in araba); // true
console.log("'model' arabada var mı?", 'model' in araba); // false

// Virgül Operatörü
let i = 0, j = 10;
for (; i < 5; i++, j--) {
    console.log(`i: ${i}, j: ${j}`);
}
// Çıktı:
// i: 0, j: 10
// i: 1, j: 9
// i: 2, j: 8
// i: 3, j: 7
// i: 4, j: 6

Operatör Önceliği ve Gruplama

Bir ifadede birden fazla operatör olduğunda, JavaScript'in hangi işlemi önce yapacağını belirleyen kurallar vardır. Buna operatör önceliği denir. Örneğin, çarpma ve bölme işlemleri, toplama ve çıkarma işlemlerinden önce yapılır.

let sonuc1 = 2 + 3 * 4; // Önce çarpma yapılır: 2 + 12 = 14
console.log("Sonuç 1:", sonuc1);

let sonuc2 = (2 + 3) * 4; // Önce parantez içi yapılır: 5 * 4 = 20
console.log("Sonuç 2:", sonuc2);

Operatör önceliği kurallarını ezberlemek yerine, işlemlerin sırasını kontrol etmek ve kodu daha okunabilir hale getirmek için parantez () kullanmak iyi bir pratiktir.

Operatör önceliği tablosuna MDN web docs üzerinden ulaşabilirsiniz.

İfadeler (Expressions)

JavaScript'te bir ifade, bir değer üreten herhangi bir kod parçasıdır. İfadeler şunları içerebilir:

• Değişkenler (x, isim)
• Sayısal değerler (10, 3.14)
• String değerler ("Merhaba")
• Boolean değerler (true, false)
• Operatörler ve operandlar (x + 5, yas >= 18)
• Fonksiyon çağrıları (hesapla(5, 3))

JavaScript motoru, bir ifadeyi değerlendirir ve sonuç olarak tek bir değer üretir. Bu değer daha sonra bir değişkene atanabilir, bir fonksiyona argüman olarak gönderilebilir veya başka bir ifadede kullanılabilir.

let sayi = 5; // 5 bir ifadedir (literal değer)
let kare = sayi * sayi; // sayi * sayi bir ifadedir
let mesaj = "Sonuç: " + kare; // "Sonuç: " + kare bir ifadedir
let buyukMu = kare > 10; // kare > 10 bir ifadedir

console.log(mesaj); // "Sonuç: 25"
console.log(buyukMu); // true

Bu derste JavaScript'teki temel operatörleri ve ifadeleri öğrendik:

• Aritmetik Operatörler: Matematiksel hesaplamalar yapar (+, -, *, /, %, ++, --, **).
• Atama Operatörleri: Değişkenlere değer atar (=, +=, -=, *=, /=, %=, **=).
• Karşılaştırma Operatörleri: Değerleri karşılaştırır ve boolean sonuç döndürür (==, !=, ===, !==, >, <, >=, <=).
• Mantıksal Operatörler: Boolean değerler üzerinde mantıksal işlemler yapar (&&, ||, !).
• Diğer Operatörler: Koşul operatörü, typeof, instanceof gibi çeşitli işlevlere sahip operatörler.
• Operatör Önceliği: Birden fazla operatör olduğunda işlemlerin yapılma sırasını belirler. Parantezler önceliği değiştirmek için kullanılır.
• İfadeler: Bir değer üreten kod parçalarıdır.

Operatörler ve ifadeler, JavaScript kodunun temelini oluşturur ve programların mantığını kurmamızı sağlar. Sonraki derste, karşılaştırma ve mantıksal operatörleri kullanarak program akışını kontrol etmemizi sağlayan koşullu ifadeleri öğreneceğiz.