``

Değişkenler Neden Gereklidir?

Değişken, bir değeri program çalışırken saklayabilmek ve daha sonra kullanabilmek için verilen isimdir. Kullanıcının adı, ürün fiyatı, oturum durumu veya sepetteki ürün sayısı birer değişkende tutulabilir.

JavaScript’te modern değişken tanımlama işlemleri genellikle let ve const ile gerçekleştirilir:

const kullaniciAdi = 'Ada';
let sepetAdedi = 2;
let oturumAcik = true;

sepetAdedi = sepetAdedi + 1;
console.log(`${kullaniciAdi} kullanıcısının sepetinde ${sepetAdedi} ürün var.`);

Burada const, yeniden atanmayacak bir değişken oluşturur. let ise değeri sonradan değiştirilebilen veriler için kullanılır. Sepete yeni ürün eklendiğinde sepetAdedi güncellenebilir; ancak kullanıcının o işlem boyunca değişmeyen adı const ile tanımlanabilir.

Değişkenlerin hafızadaki davranışı veri türüne göre farklılaşabilir. Sayı ve boolean gibi ilkel değerler doğrudan değer mantığıyla kullanılırken nesneler referans üzerinden yönetilir. Bu nedenle bir nesneyi başka değişkene atamak her zaman bağımsız bir kopya üretmez.

Koşulların Matematiksel Mantığı

Kontrol akışının merkezinde sonucu true veya false olan ifadeler bulunur. Örneğin yaş değişkeni $y$ ise yetişkinlik koşulu $y \geq 18$ biçiminde gösterilebilir. İki şartın birlikte sağlanması gerekiyorsa mantıksal VE, alternatiflerden biri yeterliyse mantıksal VEYA kullanılır.

if-else ile Sayfa Akışını Yönetmek

if-else, farklı ve esnek koşulları değerlendirmek için idealdir. Bir üyelik sayfasının kullanıcı durumuna göre mesaj göstermesi şöyle sağlanabilir:

const yas = 22;
const oturumAcik = true;

if (!oturumAcik) {
  console.log('Lütfen önce giriş yapın.');
} else if (yas >= 18) {
  console.log('Yetişkin içerik alanına hoş geldiniz.');
} else {
  console.log('Bu bölüm için yaşınız uygun değil.');
}

Program koşulları yukarıdan aşağıya değerlendirir ve doğru olan ilk bloğu çalıştırır. Bu nedenle daha özel koşulları üstte, genel koşulları altta konumlandırmak hatalı yönlendirmeleri önler.

switch-case Ne Zaman Kullanılır?

Tek bir değişkenin birçok sabit değerle karşılaştırıldığı durumlarda switch-case daha okunaklı olabilir. Örneğin kullanıcının rolüne göre panel seçilebilir:

const rol = 'editor';
let hedefSayfa;

switch (rol) {
  case 'admin':
    hedefSayfa = '/yonetim';
    break;
  case 'editor':
    hedefSayfa = '/icerikler';
    break;
  case 'uye':
    hedefSayfa = '/profil';
    break;
  default:
    hedefSayfa = '/giris';
}

console.log(`Yönlendirilecek adres: ${hedefSayfa}`);

break kullanılmazsa program sonraki case bloklarına da geçebilir. Bazen bilinçli olarak kullanılan bu davranış, çoğu başlangıç hatasının da kaynağıdır. default ise hiçbir eşleşme bulunmadığında güvenli bir varsayılan yol sağlar.

Hangisini Seçmeliyiz?

Aralıklar, birleşik mantıksal ifadeler ve karmaşık kurallar için if-else; tek bir değerin belirli seçeneklerle eşleştirilmesi için switch-case tercih edilmelidir. Koşullar büyüdükçe karar mantığını küçük fonksiyonlara ayırmak kodun test edilmesini kolaylaştırır. Böylece sayfa akışı bir labirente değil, tabelaları düzgün yerleştirilmiş eğlenceli bir yolculuğa dönüşür.

``

Temel Mantık: Veri Ayrı, Görünüm Ayrı

Dizi, birden fazla değeri tek değişken altında tutan veri yapısıdır. İndeksli dizilerde elemanlara 0, 1, 2 gibi konumlarla; ilişkisel dizilerde ise ad, fiyat veya stok gibi anlamlı anahtarlarla erişilir.

Bir dizide $n$ eleman varsa bütün elemanları bir kez ziyaret eden döngünün çalışma maliyeti yaklaşık olarak:

şeklinde ifade edilir. Buradaki $c$, her eleman için yapılan sabit miktardaki işlemdir. Bu nedenle temel listeleme işleminin zaman karmaşıklığı $O(n)$ olur. Eleman sayısı iki katına çıktığında yapılacak iş de yaklaşık iki katına çıkar.

for ile Sıralı Verileri Yazdırmak

for döngüsü başlangıç, koşul ve artış olmak üzere üç parçadan oluşur. Dizinin indeksine veya sıra numarasına ihtiyaç duyduğumuzda oldukça kullanışlıdır.

<?php
$diller = ['PHP', 'JavaScript', 'Python', 'Go'];

for ($i = 0; $i < count($diller); $i++) {
    echo '<p>' . ($i + 1) . '. ' . $diller[$i] . '</p>';
}
?>

Burada $i, dizinin mevcut indeksini temsil eder. Diziler sıfırdan başladığı için kullanıcıya gösterilen sıra numarasında $i + 1 kullanılır. Koşulun $i <= count($diller) biçiminde yazılması, olmayan son elemana erişmeye çalışacağı için klasik bir “bir adım fazla” hatası üretir.

Dizi boyutu sık değişmiyorsa count() sonucunu önceden saklamak da mümkündür:

$toplam = count($diller);
for ($i = 0; $i < $toplam; $i++) {
    echo '<li>' . htmlspecialchars($diller[$i]) . '</li>';
}

htmlspecialchars() özel HTML karakterlerini dönüştürerek kullanıcı kaynaklı verilerin güvenli gösterilmesine yardımcı olur.

foreach ile Ürün Kartları Oluşturmak

İlişkisel ve çok boyutlu dizilerde foreach, indeks yönetme zahmetini ortadan kaldırır. Aşağıdaki veri kümesindeki her ürün bir ilişkisel dizidir:

<?php
$urunler = [
    ['ad' => 'Mekanik Klavye', 'fiyat' => 2450, 'stok' => 8],
    ['ad' => 'Kablosuz Fare', 'fiyat' => 980, 'stok' => 0],
    ['ad' => 'USB Mikrofon', 'fiyat' => 3150, 'stok' => 4]
];
?>

<section class="urun-listesi">
<?php foreach ($urunler as $urun): ?>
    <article class="urun-karti">
        <h2><?= htmlspecialchars($urun['ad']) ?></h2>
        <p><?= number_format($urun['fiyat'], 2, ',', '.') ?> TL</p>
        <strong>
            <?= $urun['stok'] > 0 ? 'Stokta var' : 'Tükendi' ?>
        </strong>
    </article>
<?php endforeach; ?>
</section>

Alternatif sözdizimindeki foreach ... endforeach yapısı, PHP ile HTML iç içeyken süslü parantezlere göre daha rahat okunur. number_format() fiyatı kullanıcı dostu hale getirirken üçlü koşul operatörü stok durumuna göre farklı metin üretir.

Boş Listeyi Unutmayın

Gerçek uygulamalarda veri kümesi her zaman dolu olmayabilir. Boş bir alan göstermek yerine kullanıcıya açıklama sunmak daha iyi bir deneyimdir:

<?php if (empty($urunler)): ?>
    <p>Henüz gösterilecek ürün bulunmuyor.</p>
<?php else: ?>
    <?php foreach ($urunler as $urun): ?>
        <div><?= htmlspecialchars($urun['ad']) ?></div>
    <?php endforeach; ?>
<?php endif; ?>

Özetle sıra numarası, belirli aralık veya indeks denetimi gerekiyorsa for; verileri doğrudan ve okunaklı şekilde dolaşmak gerekiyorsa foreach tercih edilmelidir. Veriyi dizide tutup HTML şablonunu döngüyle çoğaltmak, tekrarları azaltır ve yeni bir kayıt eklemeyi yalnızca diziye tek satır eklemek kadar kolaylaştırır.

Fonksiyon Nedir?

Fonksiyon, belirli bir görevi gerçekleştiren ve gerektiğinde çağrılabilen isimlendirilmiş kod bloğudur. Bir fonksiyon girdiler alabilir, bu girdileri işleyebilir ve sonuç döndürebilir. Matematikteki fonksiyon fikriyle programlamadaki kullanım oldukça benzerdir:

Burada $x$ girdi, $f(x)$ ise çıktıdır. Programlamada aynı yapı şöyle ifade edilebilir:

def hesapla(x):
    """x² + 2x + 1 işleminin sonucunu döndürür."""
    return x ** 2 + 2 * x + 1

sonuc = hesapla(4)
print(sonuc)  # 25

Bu örnekte hesapla fonksiyonu işlemin nasıl yapıldığını tek bir yerde saklar. Formül değişirse fonksiyonun kullanıldığı her satırı değil, yalnızca fonksiyon gövdesini güncellemek yeterlidir.

Tekrar Neden Tehlikelidir?

Aynı kodun birden fazla yerde bulunması, hata düzeltmelerini zorlaştırır. Örneğin indirim hesaplayan formülü beş farklı noktaya kopyaladıysanız oran değiştiğinde beş yeri de bulmanız gerekir. Birini unutursanız program farklı sonuçlar üretmeye başlar.

Tekrarlı kod miktarını kabaca şöyle düşünebiliriz:

Burada $n$ tekrar sayısını, $m$ ise işlemin satır sayısını temsil eder. İşlem 8 satırsa ve 6 kez tekrarlanıyorsa toplam $48$ satır yönetilir. Fonksiyon kullanıldığında mantık yalnızca 8 satırda tutulur; diğer yerlerde kısa fonksiyon çağrıları bulunur.

Parametreler ve Dönüş Değerleri

İyi tasarlanmış fonksiyonlar dışarıdan parametre alır ve sonucu return ile döndürür. Böylece belirli değerlere bağımlı kalmazlar.

def indirimli_fiyat(fiyat, indirim_orani=0.10):
    """Fiyata belirtilen oranda indirim uygular."""
    if fiyat < 0:
        raise ValueError("Fiyat negatif olamaz.")

    indirim = fiyat * indirim_orani
    return fiyat - indirim

urunler = [250, 400, 750]
sonuclar = [indirimli_fiyat(urun, 0.20) for urun in urunler]
print(sonuclar)

Fonksiyon hem farklı ürünlerde kullanılabilir hem de varsayılan indirim oranı sayesinde esnekliğini korur. Değer doğrulamasının fonksiyon içinde yapılması, hatalı verilerin sisteme sessizce yayılmasını da önler.

Modüler Kodlama Nedir?

Fonksiyonlar tek tek görevleri düzenlerken modüler kodlama, ilişkili fonksiyonları ayrı dosyalarda toplar. Örneğin bir e-ticaret uygulamasında fiyat işlemleri fiyat.py, kullanıcı işlemleri kullanici.py, veritabanı işlemleri ise veritabani.py modülünde tutulabilir.

# fiyat.py
def vergi_ekle(fiyat, oran=0.20):
    return fiyat * (1 + oran)


def indirim_uygula(fiyat, oran):
    return fiyat * (1 - oran)

Başka bir dosyada bu modül şöyle kullanılır:

from fiyat import vergi_ekle, indirim_uygula

ara_toplam = indirim_uygula(1000, 0.15)
toplam = vergi_ekle(ara_toplam)
print(toplam)

Bu ayrım, ana programın ayrıntılara boğulmasını engeller. Kod, uzun bir yapılacaklar listesi yerine anlamlı görevlerin orkestrasyonu gibi görünür.

İyi Fonksiyon Yazmanın Altın Kuralları

• Her fonksiyon mümkünse tek bir sorumluluğa sahip olmalıdır.
• islem1 yerine siparis_toplamini_hesapla gibi açıklayıcı isimler kullanılmalıdır.
• Gereksiz küresel değişkenlerden kaçınılmalıdır.
• Çok fazla parametre alan fonksiyonlar yeniden tasarlanmalıdır.
• Tekrarlanan mantık ortak bir fonksiyona taşınmalıdır.
• Fonksiyonlar küçük ve bağımsız testlerle doğrulanmalıdır.

Fonksiyonlara ayırmak yalnızca satır sayısını azaltmaz; programın düşünce yapısını görünür kılar. Kodunuzda sık sık kopyala-yapıştır yapıyorsanız küçük bir alarm çalmalıdır: Orada muhtemelen keşfedilmeyi bekleyen bir fonksiyon vardır!

Formdan veritabanına uzanan yol

Tarayıcıda doldurulan alanlar genellikle GET veya POST yöntemiyle sunucuya iletilir. GET, filtreleme ve arama gibi adres çubuğunda görülebilecek işlemler için uygundur. Kişisel bilgiler veya veri değiştiren işlemler ise çoğunlukla POST kullanmalıdır. Yine de POST veriyi kendiliğinden güvenli yapmaz; yalnızca URL dışında taşır. İletişimin şifrelenmesi için HTTPS gerekir.

Sağlıklı bir veri akışı şu aşamalardan oluşur:

1. İstek yöntemini ve içerik türünü kontrol etme
2. Beklenen alanları alma
3. Veriyi normalize etme ve gereksiz boşlukları temizleme
4. Tür, biçim, uzunluk ve iş kuralı doğrulaması yapma
5. Parametreli sorguyla veritabanına yazma
6. Gösterim sırasında bağlama uygun çıktı kodlaması uygulama

Filtreleme ve doğrulama aynı şey değildir

Bir alanın kabul koşulunu matematiksel olarak şöyle düşünebiliriz:

Sunucu tarafında güvenli örnek

Aşağıdaki PHP örneği; adı, e-posta adresini ve yaşı doğrular. Tarayıcıdaki required, min veya type="email" kontrolleri kullanıcı deneyimini iyileştirir, fakat geliştirici araçlarıyla aşılabildiği için güvenlik sınırı sayılmaz.

<?php
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    http_response_code(405);
    exit('Yalnızca POST kabul edilir.');
}

$name = trim($_POST['name'] ?? '');
$email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);
$age = filter_input(INPUT_POST, 'age', FILTER_VALIDATE_INT, [
    'options' => ['min_range' => 18, 'max_range' => 120]
]);

$errors = [];

if ($name === '' || mb_strlen($name) > 80) {
    $errors[] = 'Ad alanı 1-80 karakter olmalıdır.';
}

if ($email === false || $email === null) {
    $errors[] = 'Geçerli bir e-posta adresi girilmelidir.';
}

if ($age === false || $age === null) {
    $errors[] = 'Yaş 18 ile 120 arasında olmalıdır.';
}

if ($errors) {
    http_response_code(422);
    exit(implode("\n", $errors));
}

Kod, eksik alanlar için varsayılan değer kullanır ve her hatayı ayrı biçimde toplar. HTTP 422 cevabı, isteğin anlaşılmasına rağmen verilerin kurallara uymadığını belirtir.

SQL enjeksiyonuna kapıyı kapatmak

Doğrulanan değerler bile SQL metnine birleştirilmemelidir. PDO prepared statement kullanıldığında sorgu ile veri ayrı kanallardan işlenir:

$stmt = $pdo->prepare(
    'INSERT INTO users (name, email, age) VALUES (:name, :email, :age)'
);

$stmt->execute([
    'name' => $name,
    'email' => $email,
    'age' => $age
]);

Bu yaklaşım SQL enjeksiyonuna karşı temel savunmadır. Veritabanında ayrıca UNIQUE, NOT NULL ve uygun sütun türleri tanımlanmalıdır; çünkü güvenlik tek bir kontrol noktasına emanet edilmez.

Son olarak formlara CSRF token eklenmeli, hassas alanlar günlüklere yazılmamalı ve hata mesajlarında sorgu ayrıntıları gösterilmemelidir. Veritabanından okunan içerik HTML içinde sunulurken htmlspecialchars ile kodlanmalıdır. Kısacası doğru sıra şudur: istemcide kolaylaştır, sunucuda doğrula, parametreli sorguyla kaydet ve gösterirken güvenli biçimde kodla.

Geometrinin yapı taşları

İki boyutlu düzlemde bir noktayı $P=(x,y)$ biçiminde gösteririz. İki noktanın farkı ise bir vektördür: $AB=B-A$. Uzaklık hesabında Öklid formülü kullanılır:

Geometrik algoritmaların gizli kahramanı çapraz çarpımdır. $A$, $B$ ve $C$ noktaları için yönelim değeri şöyledir:

Sonucun işareti, üç noktanın dönüş yönünü söyler:

Bu işlem yalnızca çarpma ve çıkarma içerdiği için açı hesaplamaktan daha hızlıdır. Tamsayı koordinatlarda kayan nokta hatalarını da önler.

struct Point {
    long long x, y;
};

long long cross(Point a, Point b, Point c) {
    return (b.x - a.x) * (c.y - a.y)
         - (b.y - a.y) * (c.x - a.x);
}

Bu fonksiyon; dönüş yönü, doğru parçalarının kesişimi ve dışbükeylik kontrolü gibi birçok işlemin ortak motorudur.

Çokgen alanı ve yönü

Köşeleri sırayla verilen basit bir çokgenin alanı, ayakkabı bağı formülüyle bulunabilir:

İndisler döngüseldir; yani son noktadan sonra yeniden ilk nokta gelir. Mutlak değer alınmadan önce toplamın işareti, köşelerin saat yönünde mi yoksa ters yönde mi sıralandığını da gösterir.

Dışbükey örtü: Noktaların etrafına lastik geçirmek

Dışbükey örtü, verilen bütün noktaları kapsayan en küçük dışbükey çokgendir. Sezgisel olarak noktaların çevresine bir lastik geçirip bıraktığımızda oluşan sınırdır. Monotonic Chain algoritması önce noktaları $(x,y)$ sırasına göre sıralar, ardından alt ve üst zincirleri kurar.

vector<Point> convexHull(vector<Point> p) {
    sort(p.begin(), p.end(), [](Point a, Point b) {
        return a.x != b.x ? a.x < b.x : a.y < b.y;
    });

    vector<Point> h;
    for (int pass = 0; pass < 2; pass++) {
        size_t start = h.size();
        for (Point q : p) {
            while (h.size() >= start + 2 &&
                   cross(h[h.size()-2], h.back(), q) <= 0)
                h.pop_back();
            h.push_back(q);
        }
        h.pop_back();
        reverse(p.begin(), p.end());
    }
    return h;
}

Sıralama $O(n\log n)$, zincirleri oluşturma ise $O(n)$ sürer. cross <= 0 kullanımı, aynı kenar üzerindeki ara noktaları örtüden çıkarır. Bu noktalar da sonuçta isteniyorsa koşul problem tanımına göre değiştirilmelidir.

Tarama doğrusu: Olayları sırayla işle

Tarama doğrusu yaklaşımında hayali bir doğru düzlem boyunca hareket eder. Algoritma bütün geometrik şekilleri sürekli incelemek yerine yalnızca başlangıç, bitiş ve kesişim gibi olaylarda işlem yapar.

Örneğin yatay doğru parçalarının çakışmasını ararken başlangıç noktası aktif kümeye eklenir, bitiş noktası geldiğinde çıkarılır. Dikey bir parça işlendiğinde aktif kümede onun $y$ aralığına düşen parçalar sorgulanır. Dengeli bir arama ağacı kullanılırsa ekleme, silme ve arama işlemleri $O(\log n)$ zamanda yapılabilir.

Tarama doğrusu uygulamalarındaki kritik ayrıntı, aynı koordinattaki olayların sırasıdır. Bir parçanın bitişi, diğerinin başlangıcıyla çakışıyorsa kesişimin sayılıp sayılmayacağına göre olay öncelikleri belirlenmelidir. Geometride şeytan ayrıntıda, hata ise çoğunlukla eşitlik durumundadır!

``

Dosya yükleme nasıl çalışır?

Tarayıcı, dosyayı genellikle multipart/form-data biçiminde HTTP isteğine ekler. Sunucu dosyayı geçici bir dizine alır, uygulama da doğrulama tamamlandıktan sonra kalıcı konuma taşır. Kritik nokta şudur: Kullanıcı tarafından gönderilen hiçbir bilgi güvenilir kabul edilmemelidir.

Bir yükleme isteğinin yaklaşık maliyetini şöyle düşünebiliriz:

Burada büyük dosyalar yalnızca disk alanını değil; ağ trafiğini, belleği ve işlem süresini de tüketir. Bu nedenle uygulama seviyesindeki sınırın yanında web sunucusu ve PHP yapılandırmasında da boyut sınırı bulunmalıdır.

Formun hazırlanması

Formda enctype belirtilmezse dosya içeriği sunucuya doğru biçimde ulaşmaz:

<form action="upload.php" method="post" enctype="multipart/form-data">
  <input type="hidden" name="csrf_token" value="SUNUCUDA_URETILEN_TOKEN">
  <input type="file" name="document" accept="image/jpeg,image/png,application/pdf" required>
  <button type="submit">Güvenli biçimde yükle</button>
</form>

accept özelliği kullanıcı deneyimini iyileştirir fakat güvenlik önlemi değildir; istek elle değiştirilerek başka dosyalar gönderilebilir. CSRF belirteci ise başka bir sitenin kullanıcı adına yükleme başlatmasını zorlaştırır.

PHP ile güvenli doğrulama

Aşağıdaki örnek; yükleme hatasını, boyutu ve gerçek MIME türünü denetler. Ayrıca tahmin edilmesi güç bir dosya adı üretir:

<?php
session_start();

if (!hash_equals($_SESSION['csrf_token'] ?? '', $_POST['csrf_token'] ?? '')) {
    http_response_code(403);
    exit('Geçersiz istek.');
}

$file = $_FILES['document'] ?? null;

if (!$file || $file['error'] !== UPLOAD_ERR_OK) {
    exit('Dosya yüklenemedi.');
}

$maxSize = 5 * 1024 * 1024; // 5 MB
if ($file['size'] > $maxSize) {
    exit('Dosya boyutu sınırı aşıldı.');
}

$finfo = new finfo(FILEINFO_MIME_TYPE);
$mime = $finfo->file($file['tmp_name']);
$allowed = [
    'image/jpeg' => 'jpg',
    'image/png' => 'png',
    'application/pdf' => 'pdf'
];

if (!isset($allowed[$mime])) {
    exit('Desteklenmeyen dosya türü.');
}

$name = bin2hex(random_bytes(16)) . '.' . $allowed[$mime];
$target = dirname(__DIR__) . '/private_uploads/' . $name;

if (!move_uploaded_file($file['tmp_name'], $target)) {
    exit('Dosya kaydedilemedi.');
}

echo 'Yükleme tamamlandı.';

finfo, yalnızca kullanıcının bildirdiği türe güvenmek yerine dosya içeriğini inceler. random_bytes tabanlı adlandırma ise rapor.php.jpg gibi yanıltıcı adları ve aynı isimli dosyaların birbirini ezmesini engeller.

Görseller için ek savunmalar

Bir dosyanın MIME türünün görsel görünmesi, tamamen güvenli olduğu anlamına gelmez. Görseller mümkünse GD veya Imagick ile açılıp yeniden kodlanmalıdır. Belgeler antivirüs servisiyle taranabilir; yüksek riskli sistemlerde tarama bitene kadar karantina dizininde tutulmalıdır.

Son olarak dosyaları doğrudan tahmin edilebilir URL’lerle sunmak yerine, kullanıcının erişim yetkisini kontrol eden bir indirme uç noktası kullanın. Böylece güvenli yükleme tek bir if koşulu değil, birbirini tamamlayan savunma katmanlarından oluşan sağlam bir kale hâline gelir.

İlişkisel modelin temel mantığı

İlişkisel veritabanlarında bilgiler, gereksiz tekrarı azaltmak amacıyla farklı tablolara ayrılır. Örneğin her sipariş satırına müşterinin adını ve e-posta adresini yazmak yerine, sipariş tablosunda yalnızca müşteriyi işaret eden bir kimlik tutulur.

musteriler tablosundaki id alanı birincil anahtar (PRIMARY KEY), siparisler tablosundaki musteri_id alanı ise yabancı anahtar (FOREIGN KEY) olabilir. Aralarındaki ilişki şöyle ifade edilir:

Bir müşteri birden fazla sipariş verebildiği için bu, bire-çok ilişkisidir. Müşteri başına ortalama sipariş sayısı basitçe şu şekilde düşünülebilir:

JOIN işlemi tabloları fiziksel olarak birleştirmez. Sorgu çalışırken koşula uyan satırlardan geçici bir sonuç kümesi üretir. Yani veritabanı mobilyalarını birbirine vidalamaz; yalnızca aynı fotoğraf karesine alır.

INNER JOIN ve LEFT JOIN karşılaştırması

INNER JOIN kullanımı

INNER JOIN, iki tabloda da eşleşmesi bulunan satırları döndürür. Sipariş vermiş müşterileri ve siparişlerini listeleyelim:

SELECT
    m.id,
    m.ad,
    s.id AS siparis_id,
    s.tutar
FROM musteriler AS m
INNER JOIN siparisler AS s
    ON m.id = s.musteri_id;

Buradaki ON bölümü eşleşmenin hangi koşula göre yapılacağını belirtir. AS ile tanımlanan kısa tablo adları sorguyu okunabilir kılar. Siparişi olmayan bir müşteri bu sonuçta görünmez; çünkü eşleşme yalnızca tek tarafta kalmıştır.

LEFT JOIN kullanımı

Şimdi mağazaya kayıtlı bütün müşterileri, sipariş vermemiş olsalar bile görmek istediğimizi düşünelim:

SELECT
    m.id,
    m.ad,
    s.id AS siparis_id,
    s.tutar
FROM musteriler AS m
LEFT JOIN siparisler AS s
    ON m.id = s.musteri_id;

LEFT JOIN, soldaki musteriler tablosunun bütün satırlarını korur. Eşleşen sipariş yoksa siparis_id ve tutar alanları NULL görünür. Sipariş vermeyen müşterileri bulmak için bu davranıştan yararlanabiliriz:

SELECT m.id, m.ad
FROM musteriler AS m
LEFT JOIN siparisler AS s
    ON m.id = s.musteri_id
WHERE s.id IS NULL;

Bu sorgu, pazarlama ekibinin “Sepetler neden bu kadar sessiz?” araştırmasına güzel bir başlangıç olabilir.

ON ve WHERE tuzağı

LEFT JOIN kullanırken sağ tabloya ait filtreyi WHERE bölümüne dikkatsizce eklemek, sorguyu fiilen INNER JOIN gibi davranmaya zorlayabilir:

-- Siparişi olmayan müşterileri sonuçtan çıkarır
SELECT m.ad, s.tutar
FROM musteriler AS m
LEFT JOIN siparisler AS s ON m.id = s.musteri_id
WHERE s.tutar > 1000;

Eşleşmeyen satırlarda s.tutar değeri NULL olduğundan koşul sağlanmaz. Sol tablonun tamamını korumak istiyorsak filtreyi birleştirme koşuluna taşıyabiliriz:

SELECT m.ad, s.tutar
FROM musteriler AS m
LEFT JOIN siparisler AS s
    ON m.id = s.musteri_id
   AND s.tutar > 1000;

Performans ve okunabilirlik

JOIN sütunlarına indeks eklemek, özellikle büyük tablolarda eşleşme aramasını hızlandırabilir. Ayrıca SELECT * yerine yalnızca gerekli sütunları seçmek ağ trafiğini ve bellek kullanımını azaltır. Sütun adlarını tablo takma adlarıyla nitelemek de belirsizliği önler.

Özetle, yalnızca karşılıklı eşleşen kayıtlar gerekiyorsa INNER JOIN; soldaki ana listenin tamamı korunacaksa LEFT JOIN tercih edilir. Doğru anahtarlar, bilinçli filtreler ve anlaşılır sorgular sayesinde dağınık görünen tablolar anlamlı bir veri hikâyesine dönüşür.

OOP mantığı: Sınıf plan, nesne üründür

Bir sınıf, belirli bir varlığın hangi verilere ve davranışlara sahip olacağını tanımlayan plandır. Nesne ise bu plandan oluşturulan somut örnektir. Örneğin User sınıfı bir mimari proje ise $ayse ve $mehmet bu projeye göre inşa edilmiş iki farklı ev gibidir.

Bir sınıfın durumunu özellikler, davranışlarını ise metotlar temsil eder. Bunu matematiksel olarak şöyle düşünebiliriz:

Durum; ad, e-posta veya bakiye gibi verilerden, davranış ise giriş yapma, ödeme gerçekleştirme veya bilgileri güncelleme gibi işlemlerden oluşur.

PHP ile ilk sınıfımız

Aşağıdaki sınıf, kullanıcı verisini ve kullanıcıya ait bir davranışı aynı yapı içerisinde toplar:

<?php

class User
{
    public function __construct(
        private string $name,
        private string $email
    ) {}

    public function getEmail(): string
    {
        return $this->email;
    }

    public function introduce(): string
    {
        return "Merhaba, ben {$this->name}.";
    }
}

$user = new User("Ayşe", "ayse@example.com");
echo $user->introduce();

__construct() metodu nesne oluşturulurken otomatik çalışır. private özellikler dışarıdan doğrudan değiştirilemez; böylece nesnenin iç durumu korunur. $this ise çalışılan mevcut nesneyi ifade eder. Tip bildirimleri sayesinde yanlış veri kullanımı daha erken fark edilir.

OOP’nin dört temel direği

OOP yalnızca kodu sınıflara bölmek değildir. Yaklaşımın arkasında dört önemli ilke bulunur:

1. Kapsülleme: Veriyi ve o veriyi işleyen metotları aynı yapıda toplar. İç ayrıntılar dış dünyadan saklanır.
2. Kalıtım: Bir sınıfın özellik ve davranışlarının başka bir sınıfa aktarılmasını sağlar.
3. Çok biçimlilik: Farklı sınıfların aynı arayüz üzerinden farklı davranış göstermesine imkân verir.
4. Soyutlama: Gereksiz ayrıntıları gizleyerek yalnızca kullanılacak sözleşmeyi öne çıkarır.

Ödeme sisteminde çok biçimlilik oldukça kullanışlıdır:

interface PaymentMethod
{
    public function pay(float $amount): bool;
}

class CreditCardPayment implements PaymentMethod
{
    public function pay(float $amount): bool
    {
        // Banka servisine ödeme isteği gönderilir.
        return $amount > 0;
    }
}

class BankTransferPayment implements PaymentMethod
{
    public function pay(float $amount): bool
    {
        // Havale kaydı oluşturulur.
        return $amount > 0;
    }
}

Her iki sınıf da PaymentMethod sözleşmesine uyar. Uygulamanın geri kalanı ödemenin kartla mı yoksa havaleyle mi yapıldığını bilmek zorunda değildir. Yeni bir yöntem eklemek, mevcut kodu dağıtıp yeniden toplamaya dönüşmez.

Kurumsal projelerde neden tercih edilir?

Kurumsal yazılımlar sürekli değişir. Bugün tek ödeme sağlayıcısı kullanan sistem yarın üç farklı sağlayıcıya bağlanabilir. OOP; SOLID, katmanlı mimari, bağımlılık enjeksiyonu ve tasarım desenleri gibi yaklaşımlara zemin hazırlar. Laravel ve Symfony gibi PHP framework’lerinin servis, controller, entity ve repository yapıları da bu temele dayanır.

Yine de her şeyi sınıfa çevirmek iyi mimari değildir. Her sınıfın tek ve anlaşılır bir sorumluluğu olmalı; devasa sınıflardan ve gereksiz kalıtımdan kaçınılmalıdır. Amaç daha fazla kod yazmak değil, değişikliğin maliyetini azaltmaktır. İyi modellenmiş bir PHP projesinde sınıflar yalnızca sözdizimi aracı değil, yazılımın iş dünyasını anlatan yaşayan bir haritadır.

``

HTTP Neden Kullanıcıyı Hatırlamaz?

Her HTTP isteği bağımsız değerlendirilir. Kullanıcı /login adresinde doğru parolayı girdikten sonra /profile sayfasına geçtiğinde tarayıcının kimliğini yeniden kanıtlaması gerekir. Teorik olarak doğrulama maliyetini şöyle düşünebiliriz:

Her istekte parola doğrulamak yerine ilk doğrulamada bir oturum oluşturulursa yaklaşık maliyet şu hâle gelir:

Oturum kontrolü, parola özeti hesaplamaktan çok daha hızlıdır. Üstelik parola her istekte ağ üzerinde dolaşmaz.

Cookie ve Session Arasındaki Fark

Cookie, tarayıcının sakladığı ve uygun isteklerle sunucuya gönderdiği küçük bir anahtar-değer verisidir. Session ise kullanıcıya ait geçici durumun sunucuda saklanmasıdır. Tarayıcı genellikle yalnızca tahmin edilmesi zor bir oturum kimliği taşır.

Örneğin theme=dark doğrudan cookie içinde tutulabilir. Ancak role=admin değerine güvenmek tehlikelidir; kullanıcı tarayıcı araçlarıyla bunu değiştirebilir. Yetki bilgisi sunucuda doğrulanmalıdır.

Express ile Login ve Logout

Aşağıdaki örnek, oturum verisini sunucuda tutar ve tarayıcıya yalnızca oturum kimliğini içeren cookie gönderir:

import express from "express";
import session from "express-session";
import bcrypt from "bcrypt";

const app = express();
app.use(express.json());

app.use(session({
  secret: process.env.SESSION_SECRET,
  resave: false,
  saveUninitialized: false,
  cookie: {
    httpOnly: true,
    secure: process.env.NODE_ENV === "production",
    sameSite: "lax",
    maxAge: 1000 * 60 * 30
  }
}));

app.post("/login", async (req, res) => {
  const user = await findUserByEmail(req.body.email);
  const valid = user && await bcrypt.compare(req.body.password, user.passwordHash);

  if (!valid) return res.status(401).json({ error: "Geçersiz bilgiler" });

  req.session.regenerate(error => {
    if (error) return res.sendStatus(500);
    req.session.userId = user.id;
    res.json({ message: "Giriş başarılı" });
  });
});

app.post("/logout", (req, res) => {
  req.session.destroy(error => {
    if (error) return res.sendStatus(500);
    res.clearCookie("connect.sid");
    res.sendStatus(204);
  });
});

httpOnly, JavaScript’in cookie değerini okumasını engelleyerek XSS saldırılarının etkisini azaltır. secure, cookie’nin yalnızca HTTPS üzerinden gönderilmesini sağlar. sameSite, başka sitelerden başlatılan istekleri sınırlayarak CSRF riskini düşürür. Login sonrasında regenerate kullanılması ise saldırganın önceden bildiği bir kimliği kurbana kullandırdığı session fixation saldırısına karşı önemlidir.

Tercihler Nerede Saklanmalı?

Gerçek projelerde varsayılan bellek tabanlı session deposu kullanılmamalıdır; süreç yeniden başlayınca oturumlar kaybolur ve birden fazla sunucu arasında paylaşılmaz. Redis gibi süre sonu destekleyen merkezi bir depo daha uygundur.

Son olarak logout yalnızca arayüzde kullanıcıyı giriş sayfasına göndermek değildir. Sunucudaki oturum gerçekten yok edilmeli, cookie temizlenmeli ve hassas işlemlerde gerekirse tüm cihazlardaki oturumları iptal edebilmek için kullanıcı bazlı bir oturum listesi tutulmalıdır. Kısacası iyi bir giriş sistemi, kapıyı açmayı bildiği kadar kapatmayı da bilmelidir.

Oyun teorisinin temel bileşenleri

Bir oyun; oyuncular, oyuncuların seçebileceği stratejiler, oyunun mevcut durumu ve sonuçları değerlendiren kazanç fonksiyonundan oluşur. İki oyunculu sıfır toplamlı bir oyunda bir tarafın kazancı, diğer tarafın kaybıdır. Kazançlar $u_1$ ve $u_2$ ile gösterilirse:

Satranç, dama ve tic-tac-toe bu modele oldukça uygundur. Bu oyunlarda oyuncular sırayla hareket eder, oyun durumu herkes tarafından görülür ve şans faktörü bulunmaz. Böyle oyunlara deterministik, tam bilgili oyunlar denir.

Minimax nasıl düşünür?

Minimax algoritmasında bir oyuncuya MAX, diğerine MIN adı verilir. MAX en yüksek skoru seçmeye, MIN ise bu skoru mümkün olduğunca düşürmeye çalışır. Algoritma, rakibin hata yapacağını ummaz; tam tersine, rakibin her zaman en iyi hamleyi oynayacağını varsayar. Biraz karamsardır ama hazırlıksız yakalanmaz!

Bir $s$ durumu için minimax değeri şöyle tanımlanabilir:

Buradaki $s’$, mevcut durumdan ulaşılabilen çocuk durumlardan biridir. Terminal durumda ise değer doğrudan kazanç fonksiyonundan alınır.

Python ile minimax uygulaması

Aşağıdaki fonksiyon, önceden oluşturulmuş bir oyun ağacını dolaşır. Yaprak düğümler sayısal sonuçları, listeler ise olası hamleleri temsil eder:

def minimax(node, maximizing):
    # Sayıya ulaştıysak oyun bitmiştir.
    if isinstance(node, int):
        return node

    scores = [minimax(child, not maximizing) for child in node]

    # MAX en büyük, MIN en küçük sonucu seçer.
    return max(scores) if maximizing else min(scores)

# MAX oyuncusunun üç farklı hamlesi
 game_tree = [
    [3, 5, 2],
    [9, 1, 4],
    [6, 7, 8]
]

print(minimax(game_tree, True))  # Çıktı: 6

MIN her dalda en düşük değeri seçeceği için dalların değerleri sırasıyla $2$, $1$ ve $6$ olur. MAX da bunların en büyüğü olan $6$ değerli üçüncü hamleyi tercih eder. Böylece karar formülü $\max(2,1,6)=6$ olur.

Kazanma stratejisi nasıl hesaplanır?

Öncelikle geçerli tüm hamleler üretilir ve her hamle için oluşacak durum hesaplanır. Oyun sonuna ulaşılabiliyorsa gerçek fayda değeri kullanılır. Satranç gibi ağacı devasa olan oyunlarda ise belirli bir derinlikte durularak taş üstünlüğü, hareketlilik ve şah güvenliği gibi ölçütlerden oluşan bir sezgisel değerlendirme fonksiyonu çalıştırılır.

Alfa-beta budama, sonucu değiştirmeyeceği kesinleşen dalları incelemez. İyi bir hamle sıralamasıyla minimax’ın pratik performansını ciddi biçimde artırır. Sonuç olarak kazanma stratejisi; rakibin en güçlü cevabını hesaba katmak, en kötü sonucu güvenceye almak ve hesaplama sınırları varsa durumları doğru değerlendirmek üzerine kuruludur.