// Fonksiyonsuz - aynı kodu tekrar tekrar yazıyoruz
console.log("Merhaba, Ali!");
console.log("Merhaba, Veli!");
console.log("Merhaba, Ayşe!");

// Fonksiyonla - bir kez yaz, her yerde kullan
function selamla(isim) {
    console.log("Merhaba, " + isim + "!");
}

selamla("Ali");   // Merhaba, Ali!
selamla("Veli");  // Merhaba, Veli!
selamla("Ayşe"); // Merhaba, Ayşe!

function topla(a, b) {
    return a + b;
}

let sonuc = topla(5, 3);
console.log(sonuc); // 8

function fonksiyonAdi(parametre1, parametre2) {
    // Fonksiyon gövdesi
    // Yapılacak işlemler
    return deger; // Opsiyonel
}

// Çağırma
fonksiyonAdi(arguman1, arguman2);

// Parametresiz fonksiyon
function selamVer() {
    console.log("Merhaba Dünya!");
}
selamVer(); // Merhaba Dünya!

// Tek parametreli
function karesi(sayi) {
    return sayi * sayi;
}
console.log(karesi(5)); // 25

// Çok parametreli
function hacimHesapla(en, boy, yukseklik) {
    return en * boy * yukseklik;
}
console.log(hacimHesapla(2, 3, 4)); // 24

// Return olmadan
function bilgiYazdir(isim, yas) {
    console.log(`${isim}, ${yas} yaşında`);
    // return yok, undefined döner
}
let sonuc = bilgiYazdir("Ahmet", 25);
console.log(sonuc); // undefined

const topla = function(a, b) {
    return a + b;
};

console.log(topla(5, 3)); // 8

// Function Declaration - hoisting olur
selamla1(); // Çalışır!
function selamla1() {
    console.log("Merhaba 1");
}

// Function Expression - hoisting olmaz
// selamla2(); // HATA! selamla2 henüz tanımlı değil
const selamla2 = function() {
    console.log("Merhaba 2");
};
selamla2(); // Çalışır

const faktoriyel = function fact(n) {
    if (n <= 1) return 1;
    return n * fact(n - 1); // Kendi içinde çağırabilir
};

console.log(faktoriyel(5)); // 120
// console.log(fact(5)); // HATA! fact dışarıdan erişilemez

// Klasik fonksiyon
const topla1 = function(a, b) {
    return a + b;
};

// Arrow function
const topla2 = (a, b) => {
    return a + b;
};

// Tek satır ise süslü parantez ve return gereksiz
const topla3 = (a, b) => a + b;

console.log(topla1(2, 3)); // 5
console.log(topla2(2, 3)); // 5
console.log(topla3(2, 3)); // 5

// Çok parametreli
const topla = (a, b) => a + b;

// Tek parametreli - parantez opsiyonel
const karesi = x => x * x;
const karesi2 = (x) => x * x; // Bu da geçerli

// Parametresiz - parantez zorunlu
const rastgele = () => Math.random();

// Çok satırlı - süslü parantez ve return zorunlu
const hesapla = (a, b) => {
    const toplam = a + b;
    const carpim = a * b;
    return { toplam, carpim };
};

// Nesne döndürme - parantez içine al
const kullaniciOlustur = (isim, yas) => ({ isim, yas });
console.log(kullaniciOlustur("Ali", 25)); // { isim: "Ali", yas: 25 }

// 1. this bağlamı - Arrow function kendi this'ine sahip değil
const nesne = {
    isim: "Nesne",
    normalFn: function() {
        console.log(this.isim); // "Nesne"
    },
    arrowFn: () => {
        console.log(this.isim); // undefined (global this)
    }
};

// 2. arguments nesnesi yok
function normalFn() {
    console.log(arguments); // Çalışır
}
const arrowFn = () => {
    // console.log(arguments); // HATA!
};

// 3. Constructor olarak kullanılamaz
function Kisi(isim) {
    this.isim = isim;
}
const kisi1 = new Kisi("Ali"); // Çalışır

const KisiArrow = (isim) => {
    this.isim = isim;
};
// const kisi2 = new KisiArrow("Ali"); // HATA!

function selamla(isim) {  // isim = parametre
    console.log("Merhaba " + isim);
}

selamla("Ahmet");  // "Ahmet" = argüman

// ES6 öncesi
function selamla1(isim) {
    isim = isim || "Misafir";
    console.log("Merhaba " + isim);
}

// ES6 ile - varsayılan parametre
function selamla2(isim = "Misafir") {
    console.log("Merhaba " + isim);
}

selamla2();        // Merhaba Misafir
selamla2("Ali");   // Merhaba Ali

// Birden fazla varsayılan
function urunFiyat(fiyat, kdv = 0.18, indirim = 0) {
    return fiyat * (1 + kdv) * (1 - indirim);
}

console.log(urunFiyat(100));           // 118
console.log(urunFiyat(100, 0.08));     // 108
console.log(urunFiyat(100, 0.18, 0.1)); // 106.2

function hepsiniTopla() {
    let toplam = 0;
    for (let i = 0; i < arguments.length; i++) {
        toplam += arguments[i];
    }
    return toplam;
}

console.log(hepsiniTopla(1, 2, 3));       // 6
console.log(hepsiniTopla(1, 2, 3, 4, 5)); // 15

function hepsiniTopla(...sayilar) {
    return sayilar.reduce((toplam, sayi) => toplam + sayi, 0);
}

console.log(hepsiniTopla(1, 2, 3));       // 6
console.log(hepsiniTopla(1, 2, 3, 4, 5)); // 15

// Diğer parametrelerle birlikte
function islemYap(islem, ...sayilar) {
    if (islem === "topla") {
        return sayilar.reduce((a, b) => a + b, 0);
    } else if (islem === "carp") {
        return sayilar.reduce((a, b) => a * b, 1);
    }
}

console.log(islemYap("topla", 1, 2, 3)); // 6
console.log(islemYap("carp", 2, 3, 4));  // 24

// Nesne destructuring
function kullaniciBilgisi({ isim, yas, sehir = "Belirtilmemiş" }) {
    console.log(`${isim}, ${yas} yaşında, ${sehir}`);
}

kullaniciBilgisi({ isim: "Ali", yas: 25, sehir: "İstanbul" });
// Ali, 25 yaşında, İstanbul

kullaniciBilgisi({ isim: "Veli", yas: 30 });
// Veli, 30 yaşında, Belirtilmemiş

// Dizi destructuring
function ilkIkisi([ilk, ikinci]) {
    return ilk + ikinci;
}

console.log(ilkIkisi([10, 20, 30])); // 30

function topla(a, b) {
    return a + b;
    console.log("Bu satır çalışmaz"); // return sonrası kod çalışmaz
}

// Return olmadan
function logla(mesaj) {
    console.log(mesaj);
    // return yok, undefined döner
}

let sonuc1 = topla(2, 3);
let sonuc2 = logla("test");

console.log(sonuc1); // 5
console.log(sonuc2); // undefined

// Dizi ile
function minMax(sayilar) {
    return [Math.min(...sayilar), Math.max(...sayilar)];
}

const [min, max] = minMax([5, 2, 8, 1, 9]);
console.log(min, max); // 1, 9

// Nesne ile (önerilen)
function istatistik(sayilar) {
    const toplam = sayilar.reduce((a, b) => a + b, 0);
    const ortalama = toplam / sayilar.length;

    return {
        toplam,
        ortalama,
        adet: sayilar.length,
        min: Math.min(...sayilar),
        max: Math.max(...sayilar)
    };
}

const stats = istatistik([10, 20, 30, 40, 50]);
console.log(stats);
// { toplam: 150, ortalama: 30, adet: 5, min: 10, max: 50 }

// Destructuring ile alma
const { ortalama, toplam } = istatistik([1, 2, 3, 4, 5]);
console.log(ortalama, toplam); // 3, 15

// Kötü - derin iç içe geçmiş
function processUser(user) {
    if (user) {
        if (user.isActive) {
            if (user.age >= 18) {
                return "İşlem yapıldı";
            } else {
                return "Yaş yetersiz";
            }
        } else {
            return "Kullanıcı aktif değil";
        }
    } else {
        return "Kullanıcı yok";
    }
}

// İyi - early return
function processUser(user) {
    if (!user) return "Kullanıcı yok";
    if (!user.isActive) return "Kullanıcı aktif değil";
    if (user.age < 18) return "Yaş yetersiz";

    return "İşlem yapıldı";
}

const globalDegisken = "Her yerden erişilebilir";

function test() {
    console.log(globalDegisken); // Erişilebilir
}

test();
console.log(globalDegisken); // Erişilebilir

function test() {
    const lokalDegisken = "Sadece fonksiyon içinden";
    console.log(lokalDegisken); // Erişilebilir
}

test();
// console.log(lokalDegisken); // HATA! Dışarıdan erişilemez

if (true) {
    let blockDegisken = "Block içinde";
    const blockSabit = "Bu da block içinde";
    var varDegisken = "var block scope'u yoksayar";

    console.log(blockDegisken); // Erişilebilir
}

// console.log(blockDegisken); // HATA!
// console.log(blockSabit);    // HATA!
console.log(varDegisken);      // Erişilebilir (var hoisted)

const global = "global";

function dis() {
    const disDeğisken = "dış";

    function ic() {
        const icDegisken = "iç";

        console.log(icDegisken);   // "iç" - kendi scope'u
        console.log(disDeğisken); // "dış" - parent scope
        console.log(global);       // "global" - global scope
    }

    ic();
    // console.log(icDegisken); // HATA! İç scope'a erişemez
}

dis();

function sayacOlustur() {
    let sayac = 0;

    return function() {
        sayac++;
        return sayac;
    };
}

const sayac1 = sayacOlustur();
console.log(sayac1()); // 1
console.log(sayac1()); // 2
console.log(sayac1()); // 3

const sayac2 = sayacOlustur();
console.log(sayac2()); // 1 - Yeni sayaç, sıfırdan başlar

// Private değişken simülasyonu
function bankaHesabi(baslangicBakiye) {
    let bakiye = baslangicBakiye;

    return {
        yatir: function(miktar) {
            bakiye += miktar;
            return bakiye;
        },
        cek: function(miktar) {
            if (miktar <= bakiye) {
                bakiye -= miktar;
                return bakiye;
            }
            return "Yetersiz bakiye";
        },
        bakiyeGor: function() {
            return bakiye;
        }
    };
}

const hesap = bankaHesabi(1000);
console.log(hesap.yatir(500));    // 1500
console.log(hesap.cek(200));      // 1300
console.log(hesap.bakiyeGor());   // 1300
// console.log(hesap.bakiye);     // undefined - doğrudan erişilemez

// Function declaration - hoisting olur
selamla(); // Çalışır!

function selamla() {
    console.log("Merhaba");
}

// var - hoisting olur ama undefined
console.log(x); // undefined (hata değil!)
var x = 5;

// let ve const - hoisting olmaz (teknik olarak olur ama erişilemez)
// console.log(y); // HATA! ReferenceError
let y = 10;

// Function expression - hoisting olmaz
// carp(2, 3); // HATA!
const carp = function(a, b) {
    return a * b;
};

function islemYap(sayi, callback) {
    const sonuc = callback(sayi);
    console.log("Sonuç:", sonuc);
}

function karesiAl(x) {
    return x * x;
}

function kupuAl(x) {
    return x * x * x;
}

islemYap(5, karesiAl); // Sonuç: 25
islemYap(5, kupuAl);   // Sonuç: 125

// Anonim fonksiyon olarak
islemYap(5, function(x) {
    return x * 2;
}); // Sonuç: 10

// Arrow function olarak
islemYap(5, x => x + 10); // Sonuç: 15

// setTimeout ile
console.log("Başladı");

setTimeout(function() {
    console.log("2 saniye sonra");
}, 2000);

console.log("Devam ediyor");

// Çıktı:
// Başladı
// Devam ediyor
// 2 saniye sonra (2 saniye bekledikten sonra)

// setInterval ile
let sayac = 0;
const interval = setInterval(() => {
    sayac++;
    console.log("Sayaç:", sayac);

    if (sayac >= 5) {
        clearInterval(interval);
        console.log("Durduruldu");
    }
}, 1000);

const sayilar = [1, 2, 3, 4, 5];

// forEach
sayilar.forEach(sayi => {
    console.log(sayi * 2);
});

// map - yeni dizi oluşturur
const kareler = sayilar.map(sayi => sayi * sayi);
console.log(kareler); // [1, 4, 9, 16, 25]

// filter - koşula uyanları filtreler
const buyukler = sayilar.filter(sayi => sayi > 2);
console.log(buyukler); // [3, 4, 5]

// find - ilk eşleşeni bulur
const ilkCift = sayilar.find(sayi => sayi % 2 === 0);
console.log(ilkCift); // 2

// reduce - tek değere indirger
const toplam = sayilar.reduce((acc, sayi) => acc + sayi, 0);
console.log(toplam); // 15

// Tanımlandığı anda çalışır
(function() {
    console.log("Hemen çalıştım!");
})();

// Parametreli
(function(isim) {
    console.log("Merhaba " + isim);
})("Dünya");

// Arrow function ile
(() => {
    console.log("Arrow IIFE");
})();

// Değer döndürme
const sonuc = (function() {
    const gizli = "Gizli değer";
    return gizli.toUpperCase();
})();
console.log(sonuc); // "GİZLİ DEĞER"

// Global scope'u kirletmemek
(function() {
    const privateVar = "Dışarıdan erişilemez";
    // Kodlar...
})();

// Module pattern
const myModule = (function() {
    const privateData = [];

    return {
        add: function(item) {
            privateData.push(item);
        },
        getAll: function() {
            return [...privateData];
        }
    };
})();

myModule.add("item1");
myModule.add("item2");
console.log(myModule.getAll()); // ["item1", "item2"]

// Fonksiyon parametrelerinde - geri kalan argümanları toplar
function topla(ilk, ...kalanlar) {
    console.log("İlk:", ilk);
    console.log("Kalanlar:", kalanlar);
    return kalanlar.reduce((a, b) => a + b, ilk);
}

console.log(topla(1, 2, 3, 4, 5)); // 15
// İlk: 1
// Kalanlar: [2, 3, 4, 5]

// Destructuring'de
const [birinci, ikinci, ...geriKalan] = [1, 2, 3, 4, 5];
console.log(birinci);    // 1
console.log(ikinci);     // 2
console.log(geriKalan);  // [3, 4, 5]

// Dizi elemanlarını yayma
const dizi1 = [1, 2, 3];
const dizi2 = [4, 5, 6];
const birlesik = [...dizi1, ...dizi2];
console.log(birlesik); // [1, 2, 3, 4, 5, 6]

// Dizi kopyalama
const kopya = [...dizi1];
kopya.push(4);
console.log(dizi1); // [1, 2, 3] - değişmedi
console.log(kopya); // [1, 2, 3, 4]

// Fonksiyon çağrısında
const sayilar = [5, 2, 8, 1, 9];
console.log(Math.max(...sayilar)); // 9

// Nesne yayma
const kisi = { isim: "Ali", yas: 25 };
const guncelKisi = { ...kisi, sehir: "İstanbul" };
console.log(guncelKisi);
// { isim: "Ali", yas: 25, sehir: "İstanbul" }

const hesapMakinesi = {
    topla: (a, b) => a + b,
    cikar: (a, b) => a - b,
    carp: (a, b) => a * b,
    bol: (a, b) => b !== 0 ? a / b : "Sıfıra bölünemez",
    mod: (a, b) => a % b,
    us: (a, b) => a ** b,

    hesapla: function(a, islem, b) {
        const islemler = {
            "+": this.topla,
            "-": this.cikar,
            "*": this.carp,
            "/": this.bol,
            "%": this.mod,
            "^": this.us
        };

        const fn = islemler[islem];
        if (!fn) return "Geçersiz işlem";
        return fn(a, b);
    }
};

console.log(hesapMakinesi.hesapla(10, "+", 5));  // 15
console.log(hesapMakinesi.hesapla(10, "-", 3));  // 7
console.log(hesapMakinesi.hesapla(10, "*", 2));  // 20
console.log(hesapMakinesi.hesapla(10, "/", 0));  // "Sıfıra bölünemez"
console.log(hesapMakinesi.hesapla(2, "^", 10)); // 1024

function sifreDogrula(sifre) {
    const kurallar = [
        {
            test: s => s.length >= 8,
            mesaj: "En az 8 karakter olmalı"
        },
        {
            test: s => /[A-Z]/.test(s),
            mesaj: "En az bir büyük harf içermeli"
        },
        {
            test: s => /[a-z]/.test(s),
            mesaj: "En az bir küçük harf içermeli"
        },
        {
            test: s => /[0-9]/.test(s),
            mesaj: "En az bir rakam içermeli"
        },
        {
            test: s => /[!@#$%^&*]/.test(s),
            mesaj: "En az bir özel karakter içermeli (!@#$%^&*)"
        }
    ];

    const hatalar = kurallar
        .filter(kural => !kural.test(sifre))
        .map(kural => kural.mesaj);

    return {
        gecerli: hatalar.length === 0,
        guc: kurallar.length - hatalar.length,
        maxGuc: kurallar.length,
        hatalar
    };
}

console.log(sifreDogrula("abc"));
// { gecerli: false, guc: 1, maxGuc: 5, hatalar: [...] }

console.log(sifreDogrula("Abc123!@"));
// { gecerli: true, guc: 5, maxGuc: 5, hatalar: [] }

// Hızlı ardışık çağrıları engeller (arama kutusu için ideal)
function debounce(fn, delay) {
    let timeoutId;

    return function(...args) {
        clearTimeout(timeoutId);
        timeoutId = setTimeout(() => {
            fn.apply(this, args);
        }, delay);
    };
}

// Kullanım
const aramaYap = debounce((sorgu) => {
    console.log("Aranıyor:", sorgu);
    // API çağrısı yapılır
}, 300);

// Her tuş vuruşunda çağrılsa bile sadece 300ms sonra bir kez çalışır
aramaYap("j");
aramaYap("ja");
aramaYap("jav");
aramaYap("java");
// Sadece "java" için arama yapılır (300ms sonra)

// Çok argümanlı fonksiyonu tek argümanlı zincirleme fonksiyonlara çevirme
function curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        }
        return function(...args2) {
            return curried.apply(this, args.concat(args2));
        };
    };
}

// Normal fonksiyon
function topla(a, b, c) {
    return a + b + c;
}

const curriedTopla = curry(topla);

console.log(curriedTopla(1)(2)(3)); // 6
console.log(curriedTopla(1, 2)(3)); // 6
console.log(curriedTopla(1)(2, 3)); // 6
console.log(curriedTopla(1, 2, 3)); // 6

// Pratik örnek
const kdvHesapla = curry((oran, fiyat) => fiyat * (1 + oran));

const turkiyeKdv = kdvHesapla(0.18);
const avrupaKdv = kdvHesapla(0.20);

console.log(turkiyeKdv(100)); // 118
console.log(avrupaKdv(100));  // 120

// Hesaplama sonuçlarını önbellekle
function memoize(fn) {
    const cache = new Map();

    return function(...args) {
        const key = JSON.stringify(args);

        if (cache.has(key)) {
            console.log("Cache'den alındı");
            return cache.get(key);
        }

        console.log("Hesaplandı");
        const result = fn.apply(this, args);
        cache.set(key, result);
        return result;
    };
}

// Yavaş bir fonksiyon
function fibonacci(n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

const memoFibonacci = memoize(function fib(n) {
    if (n <= 1) return n;
    return memoFibonacci(n - 1) + memoFibonacci(n - 2);
});

console.log(memoFibonacci(40)); // Hızlı
console.log(memoFibonacci(40)); // Cache'den - anında