<p>JavaScript, web sayfalarını dinamik ve etkileşimli hale getirmek için kullanılan güçlü bir programlama dilidir. Bu etkileşimi sağlamak için JavaScript, Belge Nesne Modeli (Document Object Model, DOM) adı verilen bir yapıyı kullanır. DOM, bir web sayfasının yapısını ve içeriğini temsil eden nesne tabanlı bir modeldir. Bu makalede, DOM'un ne olduğunu, nasıl çalıştığını ve JavaScript ile nasıl kullanılacağını inceleyeceğiz.</p><h3>DOM Nedir?</h3><p>DOM, bir HTML veya XML belgesinin yapısını programatik olarak temsil eden bir modeldir. Belgeyi, ağaç yapısında bir dizi düğüm (node) ve nesne olarak modelleyerek, JavaScript gibi programlama dillerinin belge içeriğine erişmesine ve bu içeriği değiştirmesine olanak tanır. DOM, web sayfasının statik HTML yapısını dinamik hale getirir.</p><h3>DOM Ağaç Yapısı</h3><p>DOM, belgeyi hiyerarşik bir ağaç yapısı olarak temsil eder. Bu yapı, kök düğümden (document) başlayarak, elementler, metin düğümleri ve diğer düğümler arasında bağlantılar içerir.</p><p>Örnek bir HTML belgesi ve buna karşılık gelen DOM ağacı:</p><pre><code class="language-html">&lt;!DOCTYPE html&gt;
&lt;html&gt;
&lt;head&gt;
    &lt;title&gt;Başlık&lt;/title&gt;
&lt;/head&gt;
&lt;body&gt;
    &lt;h1&gt;Merhaba, Dünya!&lt;/h1&gt;
    &lt;p&gt;Bu bir paragraftır.&lt;/p&gt;
&lt;/body&gt;
&lt;/html&gt;</code></pre><p>DOM Ağacı:</p><pre><code>document
 └── html
     ├── head
     │   └── title
     │       └── "Başlık"
     └── body
         ├── h1
         │   └── "Merhaba, Dünya!"
         └── p
             └── "Bu bir paragraftır."</code></pre><h3>DOM ile Çalışma</h3><p>JavaScript kullanarak DOM ile çalışabilir, belge içeriğini dinamik olarak değiştirebilir, yeni öğeler ekleyebilir ve mevcut öğeleri silebilirsiniz. DOM ile çalışmak için JavaScript'te çeşitli yöntemler ve özellikler bulunur.</p><h3>DOM Seçicileri</h3><p>DOM öğelerini seçmek için JavaScript'te çeşitli yöntemler kullanılır:</p><ol><li><p><code>getElementById</code>: Belirli bir id'ye sahip öğeyi seçer.</p><pre><code class="language-jsx">let baslik = document.getElementById("baslik");</code></pre></li><li><p><code>getElementsByClassName</code>: Belirli bir sınıf adını taşıyan tüm öğeleri seçer.</p><pre><code class="language-jsx">let paragraflar = document.getElementsByClassName("paragraf");</code></pre></li><li><p><code>getElementsByTagName</code>: Belirli bir etiket adını taşıyan tüm öğeleri seçer.</p><pre><code class="language-jsx">let listeElemanlari = document.getElementsByTagName("li");</code></pre></li><li><p><code>querySelector</code>: Belirli bir CSS seçicisine uyan ilk öğeyi seçer.</p><pre><code class="language-jsx">let ilkParagraf = document.querySelector("p");</code></pre></li><li><p><code>querySelectorAll</code>: Belirli bir CSS seçicisine uyan tüm öğeleri seçer.</p><pre><code class="language-jsx">let tumParagraflar = document.querySelectorAll("p");</code></pre></li></ol><h3>DOM Manipülasyonu</h3><p>DOM'u manipüle etmek, yani belge içeriğini dinamik olarak değiştirmek için çeşitli yöntemler kullanılır:</p><ol><li><p><strong>İçerik Değiştirme</strong>: Bir öğenin içeriğini değiştirmek için <code>innerHTML</code> veya <code>textContent</code> özellikleri kullanılır.</p><pre><code class="language-jsx">let baslik = document.getElementById("baslik");
baslik.innerHTML = "Yeni Başlık";</code></pre></li><li><p><strong>Öğe Ekleme</strong>: Yeni bir öğe oluşturmak ve belgeye eklemek için <code>createElement</code> ve <code>appendChild</code> yöntemleri kullanılır.</p><pre><code class="language-jsx">let yeniParagraf = document.createElement("p");
yeniParagraf.textContent = "Bu yeni bir paragraf.";
document.body.appendChild(yeniParagraf);</code></pre></li><li><p><strong>Öğe Silme</strong>: Bir öğeyi belgeden silmek için <code>removeChild</code> yöntemi kullanılır.</p><pre><code class="language-jsx">let silinecekParagraf = document.getElementById("silinecek");
document.body.removeChild(silinecekParagraf);</code></pre></li><li><p><strong>Özellik Değiştirme</strong>: Bir öğenin özelliklerini değiştirmek için <code>setAttribute</code> ve <code>getAttribute</code> yöntemleri kullanılır.</p><pre><code class="language-jsx">let link = document.querySelector("a");
link.setAttribute("href", "&lt;https://www.example.com&gt;");</code></pre></li></ol><h3>DOM Olayları</h3><p>DOM olayları, kullanıcı etkileşimlerine yanıt vermek için kullanılır. Olaylar, tıklama, fare hareketi, klavye girişi gibi çeşitli etkileşimler olabilir.</p><p>Örnek bir tıklama olayı dinleyicisi:</p><pre><code class="language-jsx">let buton = document.querySelector("button");
buton.addEventListener("click", function() {
    alert("Butona tıklandı!");
});</code></pre><h3>Sonuç</h3><p>DOM, JavaScript'in web sayfalarını dinamik ve etkileşimli hale getirmek için kullandığı temel yapıdır. DOM ile çalışarak, web sayfası içeriğini ve yapısını programatik olarak değiştirebilir, kullanıcı etkileşimlerine yanıt verebilir ve zengin kullanıcı deneyimleri oluşturabilirsiniz. Bu makalede öğrendiklerinizi kullanarak, kendi JavaScript projelerinizde DOM ile etkili bir şekilde çalışabilirsiniz. İyi kodlamalar!</p>

DOM: JavaScript Programlamada Belge Nesne Modeli

<p>JavaScript, işlevselliği ve modülerliği artırmak için kullanılan güçlü bir programlama dilidir. Fonksiyonlar, JavaScript programlamasında temel yapı taşlarından biridir ve farklı türlerde fonksiyonlar, çeşitli senaryolara uygun çözümler sunar. Bu makalede, JavaScript'teki farklı fonksiyon türlerini ve nasıl kullanıldıklarını inceleyeceğiz.</p><h3>1. Fonksiyon Bildirimi (Function Declaration)</h3><p>Fonksiyon bildirimi, bir fonksiyonu tanımlamanın en yaygın yoludur. Bu tür fonksiyonlar, <code>function</code> anahtar kelimesi ile tanımlanır ve hoisting (yükselme) ile fonksiyonun tanımlandığı yerden önce de çağrılabilir.</p><p>Örnek:</p><pre><code class="language-jsx">function topla(a, b) {
    return a + b;
}

console.log(topla(5, 3)); // 8</code></pre><h3>2. Fonksiyon İfadesi (Function Expression)</h3><p>Fonksiyon ifadesi, bir fonksiyonu bir değişkene atamanın bir yoludur. Bu tür fonksiyonlar, tanımlandıktan sonra çağrılabilir ve genellikle anonim fonksiyonlar (adı olmayan fonksiyonlar) kullanılır.</p><p>Örnek:</p><pre><code class="language-jsx">let carp = function(a, b) {
    return a * b;
};

console.log(carp(4, 5)); // 20</code></pre><h3>3. Anonim Fonksiyonlar (Anonymous Functions)</h3><p>Anonim fonksiyonlar, adı olmayan fonksiyonlardır. Genellikle fonksiyon ifadelerinde veya yüksek mertebe fonksiyonlarda kullanılır.</p><p>Örnek:</p><pre><code class="language-jsx">let selamla = function() {
    console.log("Selam!");
};

selamla(); // Selam!</code></pre><h3>4. Ok Fonksiyonları (Arrow Functions)</h3><p>ES6 ile tanıtılan ok fonksiyonları, daha kısa bir sözdizimi sağlar ve <code>this</code> anahtar kelimesinin bağlamını (context) korur. Ok fonksiyonları, <code>=&gt;</code> sembolü ile tanımlanır.</p><p>Örnek:</p><pre><code class="language-jsx">let cikarma = (a, b) =&gt; a - b;

console.log(cikarma(10, 3)); // 7</code></pre><h3>5. Yüksek Mertebe Fonksiyonlar (Higher-Order Functions)</h3><p>Yüksek mertebe fonksiyonlar, başka fonksiyonları argüman olarak alabilen veya başka fonksiyonları döndürebilen fonksiyonlardır. Bu tür fonksiyonlar, fonksiyonel programlamada yaygın olarak kullanılır.</p><p>Örnek:</p><pre><code class="language-jsx">function islemler(islem, a, b) {
    return islem(a, b);
}

function bol(a, b) {
    return a / b;
}

console.log(islemler(bol, 10, 2)); // 5</code></pre><h3>6. Geri Çağırma Fonksiyonları (Callback Functions)</h3><p>Geri çağırma fonksiyonları, başka bir fonksiyona argüman olarak geçirilen ve belirli bir olay gerçekleştiğinde veya belirli bir işlem tamamlandığında çağrılan fonksiyonlardır.</p><p>Örnek:</p><pre><code class="language-jsx">function uzunIslem(callback) {
    console.log("Uzun işlem başladı...");
    setTimeout(callback, 3000); // 3 saniye sonra geri çağırma fonksiyonunu çağır
}

function islemTamamlandi() {
    console.log("İşlem tamamlandı!");
}

uzunIslem(islemTamamlandi);
// Uzun işlem başladı...
// 3 saniye sonra: İşlem tamamlandı!</code></pre><h3>7. Kendiliğinden Çağrılan Fonksiyon İfadeleri (Immediately Invoked Function Expressions - IIFE)</h3><p>Kendiliğinden çağrılan fonksiyon ifadeleri, tanımlandıktan hemen sonra çalıştırılan fonksiyonlardır. Bu tür fonksiyonlar, genellikle tek seferlik işlemler ve kapsam (scope) oluşturmak için kullanılır.</p><p>Örnek:</p><pre><code class="language-jsx">(function() {
    console.log("Bu fonksiyon hemen çalıştı!");
})();
// Bu fonksiyon hemen çalıştı!</code></pre><h3>8. Kapsam ve Kapanış (Scope and Closures)</h3><p>JavaScript'te fonksiyonlar, kendi yerel değişkenlerine ve üst kapsamlarındaki değişkenlere erişebilir. Kapanışlar, bir fonksiyonun, tanımlandığı kapsamın dışında çağrıldığında bile bu yerel değişkenlere erişmesini sağlar.</p><p>Örnek:</p><pre><code class="language-jsx">function sayac() {
    let sayi = 0;
    return function() {
        sayi++;
        console.log(sayi);
    };
}

let sayaciArtir = sayac();
sayaciArtir(); // 1
sayaciArtir(); // 2</code></pre><h3>Sonuç</h3><p>Fonksiyonlar, JavaScript'te kodunuzu modüler, okunabilir ve yeniden kullanılabilir hale getirmenin güçlü bir yoludur. Farklı fonksiyon türlerini kullanarak, belirli işlemleri gerçekleştirebilir ve bu işlemleri gerektiğinde tekrar kullanabilirsiniz. Bu makalede öğrendiklerinizi kullanarak, kendi JavaScript programlarınızda fonksiyonlarla etkili bir şekilde çalışabilirsiniz. İyi kodlamalar!</p>

Fonksiyon Türleri: JavaScript Programlamada Fonksiyon Tipleri

<p>JavaScript, işlevselliği ve modülerliği artırmak için kullanılan güçlü bir programlama dilidir. Fonksiyonlar (functions), JavaScript programlamasında temel yapı taşlarından biridir ve kodunuzu daha modüler, okunabilir ve yeniden kullanılabilir hale getirmek için kullanılır. Bu makalede, JavaScript'te fonksiyonların ne olduğunu, nasıl oluşturulduklarını ve kullanıldıklarını inceleyeceğiz.</p><h3>Fonksiyon Nedir?</h3><p>Fonksiyon, belirli bir işlemi gerçekleştirmek için tanımlanan ve gerektiğinde çağrılabilen bir kod bloğudur. Fonksiyonlar, kodu tekrar kullanma, kodu düzenleme ve karmaşıklığı yönetme konusunda büyük avantajlar sağlar.</p><p>Örnek bir fonksiyon:</p><pre><code class="language-jsx">function merhaba() {
    console.log("Merhaba, dünya!");
}</code></pre><h3>Fonksiyon Oluşturma</h3><p>JavaScript'te fonksiyon oluşturmanın birkaç farklı yolu vardır:</p><ol><li><p><strong>Fonksiyon Bildirimi (Function Declaration):</strong> Fonksiyon bildirimi, bir fonksiyonu tanımlamanın en yaygın yoludur.</p><pre><code class="language-jsx">function topla(a, b) {
    return a + b;
}</code></pre></li><li><p><strong>Fonksiyon İfadesi (Function Expression):</strong> Fonksiyon ifadesi, bir fonksiyonu bir değişkene atamanın bir yoludur.</p><pre><code class="language-jsx">let carp = function(a, b) {
    return a * b;
};</code></pre></li><li><p><strong>Anonim Fonksiyonlar (Anonymous Functions):</strong> Anonim fonksiyonlar, adı olmayan fonksiyonlardır ve genellikle fonksiyon ifadelerinde kullanılır.</p><pre><code class="language-jsx">let selamla = function() {
    console.log("Selam!");
};</code></pre></li><li><p><strong>Ok Fonksiyonları (Arrow Functions):</strong> ES6 ile tanıtılan ok fonksiyonları, daha kısa bir sözdizimi sağlar ve <code>this</code> anahtar kelimesinin davranışını değiştirir.</p><pre><code class="language-jsx">let cikarma = (a, b) =&gt; {
    return a - b;
};</code></pre></li></ol><h3>Fonksiyon Çağırma</h3><p>Bir fonksiyonu çağırmak için fonksiyonun adını ve parantezleri kullanırız. Eğer fonksiyon parametre alıyorsa, bu parametreleri parantezler içinde belirtiriz.</p><p>Örnekler:</p><pre><code class="language-jsx">function merhaba() {
    console.log("Merhaba, dünya!");
}

merhaba(); // Merhaba, dünya!</code></pre><h3>Parametreler ve Argümanlar</h3><p>Fonksiyonlar, belirli işlemleri gerçekleştirmek için parametreler alabilir. Bu parametreler, fonksiyon çağrıldığında argümanlar olarak geçilir.</p><p>Örnek:</p><pre><code class="language-jsx">function topla(a, b) {
    return a + b;
}

console.log(topla(5, 3)); // 8</code></pre><h3>Varsayılan Parametreler</h3><p>JavaScript ES6 ile birlikte, fonksiyonlara varsayılan parametreler tanımlama yeteneği eklenmiştir. Bu, bir argüman sağlanmadığında kullanılacak varsayılan bir değer belirlememizi sağlar.</p><p>Örnek:</p><pre><code class="language-jsx">function selamla(isim = "Dünya") {
    console.log(`Merhaba, ${isim}!`);
}

selamla(); // Merhaba, Dünya!
selamla("Ali"); // Merhaba, Ali!</code></pre><h3>Geri Dönüş Değeri (Return Value)</h3><p>Fonksiyonlar, genellikle bir değer döndürür. <code>return</code> anahtar kelimesi, fonksiyonun sonucunu belirler ve fonksiyonun çalışmasını sonlandırır.</p><p>Örnek:</p><pre><code class="language-jsx">function kare(x) {
    return x * x;
}

console.log(kare(4)); // 16</code></pre><h3>Fonksiyonlar İçinde Fonksiyonlar</h3><p>JavaScript'te, bir fonksiyonun içinde başka bir fonksiyon tanımlayabilir ve çağırabilirsiniz. Bu, daha karmaşık işlemleri modüler hale getirir.</p><p>Örnek:</p><pre><code class="language-jsx">function disFonksiyon() {
    console.log("Dış fonksiyon");

    function icFonksiyon() {
        console.log("İç fonksiyon");
    }

    icFonksiyon();
}

disFonksiyon();
// Dış fonksiyon
// İç fonksiyon</code></pre><h3>Fonksiyonların Yüksek Mertebe Kullanımı (Higher-Order Functions)</h3><p>Fonksiyonlar, başka fonksiyonları argüman olarak alabilir veya başka fonksiyonları döndürebilir. Bu tür fonksiyonlar, yüksek mertebe fonksiyonlar olarak adlandırılır.</p><p>Örnek:</p><pre><code class="language-jsx">function islemler(islem, a, b) {
    return islem(a, b);
}

function carp(a, b) {
    return a * b;
}

console.log(islemler(carp, 2, 3)); // 6</code></pre><h3>Sonuç</h3><p>Fonksiyonlar, JavaScript'te kodunuzu modüler, okunabilir ve yeniden kullanılabilir hale getirmenin güçlü bir yoludur. Fonksiyonları kullanarak, belirli işlemleri gerçekleştirebilir ve bu işlemleri gerektiğinde tekrar kullanabilirsiniz. Bu makalede öğrendiklerinizi kullanarak, kendi JavaScript programlarınızda fonksiyonlarla etkili bir şekilde çalışabilirsiniz. İyi kodlamalar!</p>

Functions: JavaScript Programlamada Fonksiyonlar

<p>JavaScript, veri yapılarını ve mantıklarını oluşturmak için esnek ve güçlü bir dil olarak bilinir. Diziler (arrays), JavaScript programlamasının temel taşlarından biridir ve sıralı veri koleksiyonlarını saklamak ve yönetmek için kullanılır. Bu makalede, JavaScript'te dizilerin ne olduğunu, nasıl oluşturulduklarını ve kullanıldıklarını inceleyeceğiz.</p><h3>Dizi Nedir?</h3><p>Dizi, bir veya daha fazla öğeyi sıralı bir şekilde saklayan veri yapısıdır. Her öğe, dizide belirli bir konuma (indeks) sahiptir ve bu konumlar sıfırdan başlar. Diziler, herhangi bir veri tipindeki öğeleri saklayabilir, yani sayı, metin, nesne veya başka diziler içerebilirler.</p><p>Örnek bir dizi:</p><pre><code class="language-jsx">let sayilar = [1, 2, 3, 4, 5];
let karisik = [1, "iki", { isim: "Üç" }, [4], 5];</code></pre><h3>Dizi Oluşturma</h3><p>JavaScript'te dizi oluşturmanın birkaç farklı yolu vardır:</p><ol><li><p><strong>Dizi Literali Kullanarak:</strong> En yaygın ve basit yöntemdir.</p><pre><code class="language-jsx">let meyveler = ["Elma", "Muz", "Kiraz"];</code></pre></li><li><p><code>new Array()</code> Kullanarak: Bu yöntem, JavaScript'in yerleşik <code>Array</code> yapıcısını kullanarak bir dizi oluşturur.</p><pre><code class="language-jsx">let sebzeler = new Array("Havuç", "Salatalık", "Lahana");</code></pre></li></ol><h3>Dizi Elemanlarına Erişim</h3><p>Dizi elemanlarına, dizi adı ve köşeli parantez içinde indeks numarası kullanılarak erişilir.</p><p>Örnekler:</p><pre><code class="language-jsx">let diller = ["JavaScript", "Python", "Ruby"];
console.log(diller[0]); // JavaScript
console.log(diller[1]); // Python
console.log(diller[2]); // Ruby</code></pre><h3>Dizi Metotları</h3><p>JavaScript dizileri, veri ekleme, kaldırma, arama ve dönüştürme işlemleri yapmak için çeşitli yerleşik metodlar sağlar.</p><ol><li><p><strong>push():</strong> Dizinin sonuna yeni eleman ekler.</p><pre><code class="language-jsx">let diller = ["JavaScript", "Python"];
diller.push("Ruby");
console.log(diller); // ["JavaScript", "Python", "Ruby"]</code></pre></li><li><p><strong>pop():</strong> Dizinin sonundan bir eleman çıkarır.</p><pre><code class="language-jsx">diller.pop();
console.log(diller); // ["JavaScript", "Python"]</code></pre></li><li><p><strong>shift():</strong> Dizinin başından bir eleman çıkarır.</p><pre><code class="language-jsx">diller.shift();
console.log(diller); // ["Python"]</code></pre></li><li><p><strong>unshift():</strong> Dizinin başına yeni eleman ekler.</p><pre><code class="language-jsx">diller.unshift("Java");
console.log(diller); // ["Java", "Python"]</code></pre></li><li><p><strong>length:</strong> Dizinin uzunluğunu (eleman sayısını) döner.</p><pre><code class="language-jsx">console.log(diller.length); // 2</code></pre></li><li><p><strong>splice():</strong> Belirli bir konumdan eleman ekler veya kaldırır.</p><pre><code class="language-jsx">let sayilar = [1, 2, 3, 4, 5];
sayilar.splice(2, 1); // 2. indeksten itibaren 1 eleman çıkar
console.log(sayilar); // [1, 2, 4, 5]</code></pre></li><li><p><strong>slice():</strong> Dizinin bir kısmını alır ve yeni bir dizi döner.</p><pre><code class="language-jsx">let yeniSayilar = sayilar.slice(1, 3);
console.log(yeniSayilar); // [2, 4]</code></pre></li><li><p><strong>forEach():</strong> Dizinin her elemanı için bir işlev çalıştırır.</p><pre><code class="language-jsx">diller.forEach(function(dil) {
    console.log(dil);
});
// Java
// Python</code></pre></li></ol><h3>Dizi Üzerinde Dolaşma</h3><p>Diziler üzerinde dolaşmak için çeşitli yöntemler vardır. <code>for</code> döngüsü, <code>for...of</code> döngüsü ve <code>forEach</code> metodu en yaygın kullanılan yöntemlerdir.</p><p>Örnekler:</p><pre><code class="language-jsx">let meyveler = ["Elma", "Muz", "Kiraz"];

// for döngüsü
for(let i = 0; i &lt; meyveler.length; i++) {
    console.log(meyveler[i]);
}

// for...of döngüsü
for(let meyve of meyveler) {
    console.log(meyve);
}

// forEach metodu
meyveler.forEach(function(meyve) {
    console.log(meyve);
});</code></pre><h3>Çok Boyutlu Diziler</h3><p>JavaScript'te diziler, diğer dizileri içerebilir. Bu, çok boyutlu dizilerin oluşturulmasını sağlar.</p><p>Örnek:</p><pre><code class="language-jsx">let matris = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];
console.log(matris[0][0]); // 1
console.log(matris[1][2]); // 6</code></pre><h3>Sonuç</h3><p>Diziler, JavaScript'te veriyi sıralı ve yapılandırılmış bir şekilde saklamanın güçlü bir yoludur. Dizileri kullanarak, veri koleksiyonlarını yönetebilir ve işleyebilirsiniz. Bu makalede öğrendiklerinizi kullanarak, kendi JavaScript programlarınızda dizilerle etkili bir şekilde çalışabilirsiniz. İyi kodlamalar!</p>

Arrays: JavaScript Programlamada Diziler

<p>JavaScript, veri yapılarının ve mantıklarının oluşturulmasında esnek ve güçlü bir dil olarak bilinir. Nesneler (objects), JavaScript programlamasının temel taşlarından biridir ve veriyi daha yapılandırılmış bir şekilde saklamak ve yönetmek için kullanılır. Bu makalede, JavaScript'te nesnelerin ne olduğunu, nasıl oluşturulduklarını ve kullanıldıklarını inceleyeceğiz.</p><h3>Nesne Nedir?</h3><p>Nesne, birbiriyle ilişkili veri ve işlevleri bir araya getiren bir veri yapısıdır. Nesneler, özellikler (properties) ve yöntemlerden (methods) oluşur. Özellikler, nesnenin sahip olduğu verileri temsil ederken, yöntemler bu verilere uygulanabilecek işlevleri temsil eder.</p><p>Örnek bir nesne:</p><pre><code class="language-jsx">let araba = {
    marka: "Toyota",
    model: "Corolla",
    yil: 2020,
    calistir: function() {
        console.log("Araba çalıştı");
    }
};</code></pre><p>Bu örnekte, <code>araba</code> nesnesi <code>marka</code>, <code>model</code> ve <code>yil</code> adında üç özelliğe ve <code>calistir</code> adında bir metoda sahiptir.</p><h3>Nesne Oluşturma</h3><p>JavaScript'te nesne oluşturmanın birkaç farklı yolu vardır:</p><ol><li><p><strong>Nesne Literali Kullanarak:</strong> En yaygın ve basit yöntemdir. Yukarıdaki örnek, nesne literalini kullanarak bir nesne oluşturmayı gösterir.</p><pre><code class="language-jsx">let kedi = {
    isim: "Pamuk",
    yas: 2,
    miyavla: function() {
        console.log("Miyav!");
    }
};</code></pre></li><li><p><code>new Object()</code> Kullanarak: Bu yöntem, JavaScript'in yerleşik <code>Object</code> yapıcısını kullanarak bir nesne oluşturur.</p><pre><code class="language-jsx">let kopek = new Object();
kopek.isim = "Karabaş";
kopek.yas = 3;
kopek.havla = function() {
    console.log("Hav hav!");
};</code></pre></li><li><p><strong>Constructor Fonksiyonları Kullanarak:</strong> Daha karmaşık nesneler oluşturmak için kullanılır. Bir yapıcı fonksiyon tanımlanır ve <code>new</code> anahtar kelimesi ile nesneler oluşturulur.</p><pre><code class="language-jsx">function Insan(isim, yas) {
    this.isim = isim;
    this.yas = yas;
    this.tanit = function() {
        console.log(`Merhaba, benim adım ${this.isim} ve ben ${this.yas} yaşındayım.`);
    };
}

let insan1 = new Insan("Ahmet", 30);
let insan2 = new Insan("Ayşe", 25);</code></pre></li></ol><h3>Nesne Özelliklerine ve Yöntemlerine Erişim</h3><p>Nesne özelliklerine ve yöntemlerine erişmek için nokta notasyonu (<code>.</code>) veya köşeli parantez notasyonu (<code>[]</code>) kullanılabilir.</p><p>Örnekler:</p><pre><code class="language-jsx">let kitap = {
    baslik: "JavaScript 101",
    yazar: "John Doe",
    yayinYili: 2021,
    bilgiVer: function() {
        console.log(`${this.baslik}, ${this.yazar} tarafından yazılmıştır.`);
    }
};

// Nokta Notasyonu ile Erişim
console.log(kitap.baslik); // JavaScript 101
kitap.bilgiVer(); // JavaScript 101, John Doe tarafından yazılmıştır.

// Köşeli Parantez Notasyonu ile Erişim
console.log(kitap["yazar"]); // John Doe

</code></pre><h3>Nesne Metotları</h3><p>Nesne metotları, nesne özelliklerine ve diğer metodlarına erişebilir. Bu, <code>this</code> anahtar kelimesi ile yapılır.</p><p>Örnek:</p><pre><code class="language-jsx">let ogrenci = {
    isim: "Ali",
    notlar: [90, 80, 70],
    ortalamaHesapla: function() {
        let toplam = 0;
        for(let not of this.notlar) {
            toplam += not;
        }
        return toplam / this.notlar.length;
    }
};

console.log(`${ogrenci.isim}'nin not ortalaması: ${ogrenci.ortalamaHesapla()}`); // Ali'nin not ortalaması: 80
</code></pre><h3>Nesne Üzerinde Dolaşma</h3><p>Bir nesnedeki tüm özellikleri ve değerlerini dolaşmak için <code>for...in</code> döngüsü kullanılır.</p><p>Örnek:</p><pre><code class="language-jsx">let bilgisayar = {
    marka: "Dell",
    model: "XPS 15",
    yil: 2022
};

for(let ozellik in bilgisayar) {
    console.log(`${ozellik}: ${bilgisayar[ozellik]}`);
}</code></pre><h3>Nesneye Yeni Özellik Ekleme ve Özellik Silme</h3><p>JavaScript'te mevcut bir nesneye dinamik olarak yeni özellikler eklenebilir veya mevcut özellikler silinebilir.</p><p>Örnek:</p><pre><code class="language-jsx">let telefon = {
    marka: "Apple",
    model: "iPhone 13"
};

// Yeni özellik ekleme
telefon.renk = "Siyah";
console.log(telefon.renk); // Siyah

// Özellik silme
delete telefon.model;
console.log(telefon.model); // undefined</code></pre><h3>Sonuç</h3><p>Nesneler, JavaScript'te veriyi yapılandırmanın ve yönetmenin güçlü bir yoludur. Onları kullanarak, ilişkili verileri ve işlevleri bir araya getirebilir ve kodunuzu daha modüler ve okunabilir hale getirebilirsiniz. Bu makalede öğrendiklerinizi kullanarak, kendi JavaScript programlarınızda nesnelerle etkili bir şekilde çalışabilirsiniz. İyi kodlamalar!</p>

Objects: JavaScript Programlamada Nesneler

<p>JavaScript'te veri tipleri iki ana kategoriye ayrılır: ilkel (primitive) veri tipleri ve referans (reference) veri tipleri. İlkel veri tipleri, doğrudan değeri saklayan basit veri tipleridir. Referans veri tipleri ise, nesne ve diziler gibi daha karmaşık veri yapılarını saklar ve bu yapıların bellekteki konumlarına referans eder. Bu makalede, JavaScript'te referans veri tiplerinin ne olduğunu ve nasıl çalıştıklarını inceleyeceğiz.</p><h3>Referans Veri Tipleri Nedir?</h3><p>Referans veri tipleri, değişkenin doğrudan değeri yerine, bellekteki bir yeri işaret ettiği veri tipleridir. Bu, nesne ve diziler gibi karmaşık veri yapılarının bellekte depolanma ve yönetilme şeklini etkiler.</p><p>Referans veri tiplerinin temel özellikleri:</p><ul><li><p><strong>Bellekte Bir Referans Olarak Saklanır:</strong> Referans veri tipleri, bellekte bir referans (işaretçi) olarak saklanır.</p></li><li><p><strong>Değişkenler Arasında Kopyalama:</strong> Değişkenler arasında kopyalanırken, referans kopyalanır, değer değil.</p></li><li><p><strong>Bellekte Aynı Yeri İşaret Edebilir:</strong> Bellekte aynı nesneyi veya diziyi işaret eden birden fazla değişken olabilir.</p></li></ul><p>JavaScript'te başlıca referans veri tipleri şunlardır:</p><ol><li><p><strong>Object (Nesne)</strong></p></li><li><p><strong>Array (Dizi)</strong></p></li><li><p><strong>Function (Fonksiyon)</strong></p></li></ol><h3>Referans Tiplerle İlgili Önemli Noktalar</h3><ol><li><p><strong>Değer Kopyalama:</strong> Referans tipler, değişkenler arasında kopyalandığında, sadece referans kopyalanır. Bu nedenle, bir değişkende yapılan değişiklik diğer değişkeni de etkiler.</p><pre><code class="language-jsx">let obje1 = { isim: "Ali" };
let obje2 = obje1;
obje2.isim = "Veli";
console.log(obje1.isim); // Veli</code></pre></li><li><p><strong>Karşılaştırma:</strong> Referans tipler karşılaştırılırken, değerler değil, referanslar karşılaştırılır. Bu, iki farklı nesnenin aynı değerlere sahip olsalar bile eşit olmadıkları anlamına gelir.</p><pre><code class="language-jsx">let objeA = { deger: 10 };
let objeB = { deger: 10 };
console.log(objeA === objeB); // false</code></pre></li><li><p><strong>Derin Kopyalama:</strong> Bazı durumlarda, nesnelerin veya dizilerin derin kopyalarını oluşturmak gerekebilir. Bu, nesnenin veya dizinin tüm içeriğinin bağımsız bir kopyasını oluşturur.</p><pre><code class="language-jsx">let orijinal = { isim: "Ahmet", yas: 30 };
let kopya = JSON.parse(JSON.stringify(orijinal));
kopya.isim = "Mehmet";
console.log(orijinal.isim); // Ahmet</code></pre></li></ol><h3>Sonuç</h3><p>Referans veri tipleri, JavaScript'te karmaşık veri yapılarını yönetmenin temel yollarından biridir. Nesneler, diziler ve fonksiyonlar gibi referans tipler, bellekte işaretçi olarak saklanır ve bu nedenle değişkenler arasında kopyalanırken dikkatli olunması gerekir. Bu makalede öğrendiklerinizi kullanarak, JavaScript programlarınızda referans veri tiplerini etkili bir şekilde yönetebilirsiniz. İyi kodlamalar!</p>

Referans Veri Tipleri: JavaScript Programlamada Referans Tipler

<h3>Dinamik Tip Belirleme: JavaScript Programlamada Dinamik Tipler</h3><p>JavaScript gibi modern programlama dillerinde veri tiplerinin nasıl işlendiğini ve yönetildiğini anlamak, yazılım geliştirmenin kritik bir parçasıdır. JavaScript, dinamik tip belirleme (dynamic typing) özelliği ile tanınır. Bu makalede, dinamik tip belirleme kavramını, avantajlarını ve JavaScript'teki kullanımını inceleyeceğiz.</p><h3>Dinamik Tip Belirleme Nedir?</h3><p>Dinamik tip belirleme, bir değişkenin veri tipinin, programın çalıştırılması sırasında belirlenmesidir. Yani, değişkenler herhangi bir veri tipine sahip olabilir ve bu tip, programın çalışma sürecinde değiştirilebilir. Dinamik tip belirleme, değişkenlerin tiplerinin önceden belirlenmesini gerektiren statik tip belirlemenin aksine, daha fazla esneklik sağlar.</p><p>JavaScript'te değişkenler, <code>var</code>, <code>let</code> veya <code>const</code> anahtar kelimeleri ile tanımlanır ve bu değişkenlere herhangi bir veri tipi atanabilir. Tipler, değişkenlere atanan değerlere göre dinamik olarak belirlenir.</p><p>Örnek:</p><pre><code class="language-jsx">let degisken = 42;     // Number tipi
degisken = "Merhaba";  // String tipi
degisken = true;       // Boolean tipi</code></pre><h3>Dinamik Tip Belirlemenin Avantajları</h3><ol><li><p><strong>Esneklik:</strong> Dinamik tip belirleme, geliştiricilere değişkenlerin tiplerini değiştirme esnekliği sağlar. Bu, özellikle prototip oluşturma ve hızlı geliştirme süreçlerinde faydalıdır.</p></li><li><p><strong>Daha Az Kod Yazma:</strong> Tiplerin açıkça belirtilmesine gerek olmadığı için, daha az kod yazılır ve bu da kodun daha okunabilir olmasını sağlar.</p></li><li><p><strong>Kolaylık:</strong> Dinamik tip belirleme, veri tiplerinin yönetimini geliştiriciye bırakır ve programlama sürecini kolaylaştırır.</p></li></ol><h3>JavaScript'te Dinamik Tip Belirleme</h3><p>JavaScript'te dinamik tip belirleme, dilin temel özelliklerinden biridir. Değişkenlerin tipleri, programın çalıştırılması sırasında belirlenir ve gerektiğinde değiştirilebilir. Bu esneklik, JavaScript'in güçlü yönlerinden biridir.</p><p>Örnek:</p><pre><code class="language-jsx">let veri = "JavaScript";
console.log(typeof veri); // string

veri = 2023;
console.log(typeof veri); // number

veri = { dil: "JavaScript" };
console.log(typeof veri); // object</code></pre><h3>Potansiyel Dezavantajlar ve Dikkat Edilmesi Gerekenler</h3><p>Dinamik tip belirleme, esneklik sağlasa da bazı dezavantajlara da sahiptir:</p><ol><li><p><strong>Hata Ayıklama Zorluğu:</strong> Tip hataları, çalışma zamanında ortaya çıkabilir ve bu da hata ayıklamayı zorlaştırabilir.</p></li><li><p><strong>Kodun Anlaşılabilirliği:</strong> Değişkenlerin tipleri sürekli değiştiğinde, kodun anlaşılabilirliği azalabilir ve bu da bakım zorluğu yaratabilir.</p></li><li><p><strong>Performans:</strong> Tiplerin dinamik olarak belirlenmesi, zaman zaman performans kayıplarına neden olabilir, çünkü tip kontrolü çalışma zamanında yapılır.</p></li></ol><h3>İyi Uygulamalar</h3><p>Dinamik tip belirleme ile çalışırken, bazı iyi uygulamaları takip etmek önemlidir:</p><ol><li><p><strong>Açıklayıcı İsimler Kullanın:</strong> Değişken isimlerinin, içerdiği veri tipini ve amacını açıkça belirtmesi faydalıdır.</p></li><li><p><strong>Yorum Satırları Ekleyin:</strong> Karmaşık veya değişken tiplerin kullanıldığı yerlerde, açıklayıcı yorumlar ekleyin.</p></li><li><p><strong>Kod İncelemeleri Yapın:</strong> Kod incelemeleri ve testler, tip hatalarının erken tespit edilmesine yardımcı olabilir.</p></li></ol><h3>Sonuç</h3><p>Dinamik tip belirleme, JavaScript gibi dillerde esneklik ve kolaylık sağlar. Bu özellik, değişkenlerin tiplerini çalışma zamanında belirleyerek geliştiricilere daha fazla özgürlük sunar. Ancak, dinamik tip belirlemenin getirdiği potansiyel dezavantajların farkında olmak ve iyi uygulamaları takip etmek önemlidir. Bu makalede öğrendiklerinizi kullanarak, JavaScript programlarınızda dinamik tip belirleme ile etkili ve esnek kodlar yazabilirsiniz. İyi kodlamalar!</p>

Dinamik Tip Belirleme: JavaScript Programlamada Dinamik Tipler

<p>JavaScript'te veri tiplerini anlamak, yazılım geliştirmenin temel taşlarından biridir. Bu veri tipleri, programların veriyi nasıl işleyeceğini ve saklayacağını belirler. JavaScript'te temel veri tiplerine "primitive types" (ilkel tipler) denir. Bu makalede, JavaScript'teki ilkel veri tiplerini ve bunların nasıl kullanıldığını inceleyeceğiz.</p><h3>Primitive Tipler Nelerdir?</h3><p>JavaScript'te yedi ilkel veri tipi vardır:</p><ol><li><p><strong>Number (Sayı)</strong></p></li><li><p><strong>String (Metin)</strong></p></li><li><p><strong>Boolean (Doğru/Yanlış)</strong></p></li><li><p><strong>Undefined (Tanımsız)</strong></p></li><li><p><strong>Null (Boş)</strong></p></li><li><p><strong>Symbol (Sembol)</strong></p></li><li><p><strong>BigInt (Büyük Sayı)</strong></p></li></ol><p>Bu veri tipleri, programlama sırasında en sık kullanılan ve en temel yapı taşlarıdır.</p><h3>Number (Sayı)</h3><p>Number tipi, hem tamsayıları hem de ondalıklı sayıları temsil eder. JavaScript'te tüm sayılar <code>number</code> tipindedir.</p><p>Örnekler:</p><pre><code class="language-jsx">let tamSayi = 42;
let ondalikliSayi = 3.14;
</code></pre><h3>String (Metin)</h3><p>String tipi, bir veya daha fazla karakterden oluşan metinleri temsil eder. String'ler tek tırnak (' '), çift tırnak (" ") veya ters tırnak ( ``) içinde yazılabilir.</p><p>Örnekler:</p><pre><code class="language-jsx">let tekTirnak = 'Merhaba';
let ciftTirnak = "Dünya";
let tersTirnak = `Merhaba, ${ciftTirnak}!`; // Template literal</code></pre><h3>Boolean (Doğru/Yanlış)</h3><p>Boolean tipi, sadece iki değerden birini alabilir: <code>true</code> (doğru) veya <code>false</code> (yanlış). Genellikle koşul ifadelerinde kullanılır.</p><p>Örnekler:</p><pre><code class="language-jsx">let isTrue = true;
let isFalse = false;</code></pre><h3>Undefined (Tanımsız)</h3><p>Undefined tipi, bir değişkene değer atanmadığında otomatik olarak verilen değerdir. Bir değişken tanımlandı ama henüz bir değer atanmadıysa <code>undefined</code> değerine sahip olur.</p><p>Örnek:</p><pre><code class="language-jsx">let tanimsiz;
console.log(tanimsiz); // undefined</code></pre><h3>Null (Boş)</h3><p>Null tipi, kasıtlı olarak boş veya geçersiz bir değeri temsil eder. <code>undefined</code> ile arasındaki fark, <code>null</code>'ın geliştirici tarafından atanmış olmasıdır.</p><p>Örnek:</p><pre><code class="language-jsx">let bosDeger = null;</code></pre><h3>Symbol (Sembol)</h3><p>Symbol tipi, benzersiz ve değiştirilemez bir değeri temsil eder. Genellikle nesnelerdeki anahtarları benzersiz yapmak için kullanılır.</p><p>Örnek:</p><pre><code class="language-jsx">let sembol1 = Symbol('sembol');
let sembol2 = Symbol('sembol');
console.log(sembol1 === sembol2); // false</code></pre><h3>BigInt (Büyük Sayı)</h3><p>BigInt tipi, çok büyük tamsayıları temsil etmek için kullanılır. Bu tip, normal <code>number</code> tipinin dışında kalan büyük sayıları işlemek için gereklidir.</p><p>Örnek:</p><pre><code class="language-jsx">let buyukSayi = BigInt(123456789012345678901234567890);</code></pre><h3>İlkel Tiplerin Kullanımı ve Özellikleri</h3><p>İlkel tipler, JavaScript'in temel yapı taşlarıdır ve değişmez (immutable) özelliklere sahiptir. Bu, bir ilkel tipin değerinin değiştirilemeyeceği anlamına gelir. Ancak, bir değişkenin içeriği başka bir değere atanabilir.</p><p>Örnek:</p><pre><code class="language-jsx">let metin = 'Merhaba';
metin[0] = 'm'; // Bu işlem geçersizdir
metin = 'Dünya'; // Bu geçerlidir, çünkü değişkenin kendisi değiştiriliyor</code></pre><h3>Sonuç</h3><p>JavaScript'te ilkel tipler, veriyi saklamak ve işlemek için kullanılan en temel yapı taşlarıdır. Bu tipler, programlama sırasında karşılaşacağınız en yaygın veri türleridir ve onları anlamak, JavaScript'te etkili ve doğru kod yazmanın anahtarıdır. Bu makalede öğrendiklerinizi kullanarak kendi JavaScript programlarınızda ilkel tipleri denemekten çekinmeyin. İyi kodlamalar!</p>

Primitive Tipler: JavaScript Programlamada Primitive Tipler

<p>Yazılım geliştirmeye yeni başladıysanız, sabitlerin (constants) programlamada nasıl kullanıldığını anlamanız önemlidir. Sabitler, değiştirilemez değerlere sahip olan ve program boyunca aynı kalan değişkenlerdir. JavaScript'te sabitler, <code>const</code> anahtar kelimesi kullanılarak tanımlanır. Bu makalede, JavaScript'te sabitlerin kullanımını ve neden önemli olduklarını inceleyeceğiz.</p><h3>Sabit Nedir?</h3><p>Bir sabit, değeri değiştirilemeyen bir değişkendir. Sabitler, programınızın mantığı gereği değişmemesi gereken değerleri saklamak için kullanılır. Örneğin, matematiksel sabitler, fiziksel sabitler veya yapılandırma bilgileri sabit olarak tanımlanabilir.</p><p>JavaScript'te bir sabit tanımlamak için <code>const</code> anahtar kelimesi kullanılır:</p><pre><code class="language-jsx">const PI = 3.14;</code></pre><p>Bu örnekte, <code>PI</code> isimli bir sabit oluşturulmuş ve bu sabite 3.14 değeri atanmıştır. Bu değeri daha sonra değiştiremeyiz.</p><h3>Sabitlerin Özellikleri</h3><ul><li><p><strong>Değiştirilemez Değerler:</strong> Bir sabitin değeri, bir kez atandıktan sonra değiştirilemez. Eğer bir sabitin değerini değiştirmeye çalışırsanız, hata alırsınız.</p></li><li><p><strong>Blok Kapsamı:</strong> Sabitler, let anahtar kelimesi ile tanımlanan değişkenler gibi blok kapsamına sahiptir. Bu, sabitin sadece tanımlandığı blok içinde erişilebilir olduğu anlamına gelir.</p></li><li><p><strong>Anlamlı İsimler:</strong> Sabitler genellikle büyük harflerle yazılır ve kelimeler arasında alt çizgi kullanılır. Bu, kodun okunabilirliğini artırır ve sabitlerin kolayca tanınmasını sağlar.</p></li></ul><p>Örnek:</p><pre><code class="language-jsx">const MAX_SICAKLIK = 40;
const MIN_SICAKLIK = -10;</code></pre><h3>Sabitlerin Kullanım Alanları</h3><p>Sabitler, birçok farklı senaryoda kullanılabilir:</p><ol><li><p><strong>Matematiksel Sabitler:</strong></p><pre><code class="language-jsx">const PI = 3.14159;
const EULER = 2.71828;</code></pre></li><li><p><strong>Yapılandırma Bilgileri:</strong></p><pre><code class="language-jsx">const API_URL = "&lt;https://api.example.com&gt;";
const TIMEOUT = 5000;</code></pre></li><li><p><strong>Fiziksel Sabitler:</strong></p><pre><code class="language-jsx">const GRAVITY = 9.81; // m/s^2
const SPEED_OF_LIGHT = 299792458; // m/s</code></pre></li></ol><h3>Sabitlerle İlgili Kurallar ve İpuçları</h3><ul><li><p><strong>Başlangıç Değeri:</strong> Bir sabit tanımlandığında, ona mutlaka bir başlangıç değeri atanmalıdır. Başlangıç değeri olmadan bir sabit tanımlanamaz.</p><pre><code class="language-jsx">const MAX_DEGER; // Bu, bir hata verir</code></pre></li><li><p><strong>Nesneler ve Diziler:</strong> Sabitler, nesne veya dizi içerebilir. Ancak, sabitin kendisi değiştirilemezken, içerdiği nesne veya dizinin öğeleri değiştirilebilir.</p><pre><code class="language-jsx">const AYARLAR = {
    tema: "karanlık",
    dil: "tr"
};
AYARLAR.tema = "aydınlık"; // Bu işlem geçerlidir</code></pre></li></ul><h3>Sonuç</h3><p>Sabitler, JavaScript programlarınızda değişmemesi gereken değerleri saklamak için kullanabileceğiniz önemli araçlardır. Onları kullanarak kodunuzu daha güvenilir, okunabilir ve bakım yapılabilir hale getirebilirsiniz. Bu makalede öğrendiklerinizi kullanarak kendi JavaScript programlarınızda sabitleri denemekten çekinmeyin. İyi kodlamalar!</p>

Constants: JavaScript Programlamada Sabitler

<p>Yazılım geliştirmeye yeni başladıysanız, değişkenlerin programlamada nasıl kullanıldığını anlamanız önemlidir. Değişkenler, verileri saklamak için kullanılan bir tür "kutucuk" olarak düşünülebilir ve bu verilere bir isim vererek program içinde rahatça erişebiliriz. JavaScript'te değişkenleri kullanma konusunda temel bilgileri bu makalede bulabilirsiniz.</p><h3>Değişken Nedir?</h3><p>Bir değişken, bir değeri saklamak için hafızada ayrılan bir alandır. Değişkenlere verilen isimler, bu değerlere erişmemize ve değişkenin değerini güncellememize yardımcı olur. JavaScript'te bir değişken oluşturmak için <code>var</code>, <code>let</code> veya <code>const</code> anahtar kelimeleri kullanılır.</p><pre><code class="language-jsx">let x = 10;</code></pre><p>Bu örnekte, <code>x</code> isimli bir değişken oluşturulmuş ve bu değişkene 10 değeri atanmıştır. Şimdi bu değeri başka bir yerde kullanabiliriz.</p><h3>Değişken İsimlendirme Kuralları</h3><p>JavaScript'te değişken isimlendirirken bazı kurallara dikkat etmek gerekir:</p><ul><li><p>Değişken isimleri harf veya alt çizgi ile başlamalıdır.</p></li><li><p>Değişken isimleri harf, rakam veya alt çizgi içerebilir.</p></li><li><p>Değişken isimleri büyük-küçük harf duyarlıdır. (yani, <code>degisken</code> ve <code>Degisken</code> farklı değişkenlerdir.)</p></li></ul><p>Örnekler:</p><pre><code class="language-jsx">let isim = "Ali";
let yas = 25;</code></pre><h3>Değişken Türleri</h3><p>JavaScript'te değişkenlerin türleri vardır ve bu türler dinamiktir. Bu demektir ki bir değişkenin türünü önceden belirtmenize gerek yoktur ve değişkenin türü, ona atanan değere bağlı olarak otomatik olarak belirlenir.</p><p>Örnekler:</p><pre><code class="language-jsx">let tamSayi = 10;           // number (tam sayı)
let ondalikliSayi = 3.14;   // number (ondalıklı sayı)
let metin = "Merhaba";      // string (metin)
let dogruYanlis = true;     // boolean (doğru/yanlış)</code></pre><h3>Değişkenlerle İşlemler</h3><p>Değişkenlerle matematiksel işlemler yapabilir ve sonuçları başka değişkenlere atayabilirsiniz.</p><pre><code class="language-jsx">let x = 5;
let y = 10;
let toplam = x + y;
console.log(toplam);  // 15</code></pre><h3>Sonuç</h3><p>Değişkenler, programlarınızda veri saklamak ve işlemek için kullandığınız temel araçlardır. Onlar sayesinde kodunuz daha esnek ve okunabilir hale gelir. Bu makalede öğrendiklerinizi kullanarak kendi JavaScript programlarınızda değişkenleri denemekten çekinmeyin.</p><pre><code class="language-jsx">// Tarayıcıda çalıştırmak için basit bir örnek:
&lt;!DOCTYPE html&gt;
&lt;html lang="en"&gt;
&lt;head&gt;
    &lt;meta charset="UTF-8"&gt;
    &lt;meta name="viewport" content="width=device-width, initial-scale=1.0"&gt;
    &lt;title&gt;JavaScript ile Değişkenler&lt;/title&gt;
&lt;/head&gt;
&lt;body&gt;
    &lt;h1&gt;JavaScript Değişkenler Örneği&lt;/h1&gt;
    &lt;script&gt;
        let isim = "Ali";
        let yas = 25;
        let mesaj = `Merhaba, benim adım ${isim} ve ben ${yas} yaşındayım.`;
        console.log(mesaj);
        alert(mesaj);
    &lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;</code></pre><p>Tebrikler! Artık JavaScript'te değişkenlerin nasıl kullanıldığını biliyorsunuz. Bu temel bilgilerle JavaScript programlamaya sağlam bir başlangıç yapabilirsiniz. İyi kodlamalar!</p>

Değişkenler: JavaScript Programlamada Temel Taşlar

<p>Yazılım geliştirmeye yeni başladıysanız ve JavaScript ile çalışmak istiyorsanız, Visual Studio Code (VSCode) mükemmel bir tercihtir. Bu, Microsoft tarafından geliştirilen açık kaynaklı, hafif ve güçlü bir kod editörüdür. Bu rehberde, JavaScript’i ve VSCode’u adım adım nasıl kuracağınızı anlatacağız.</p><h3>Adım 1: VSCode’un Kurulması</h3><p>Öncelikle VSCode’u kurmalısınız.</p><ol><li><p>VSCode’un resmi web sitesine gidin: <a target="_blank" rel="noopener noreferrer nofollow" href="http://code.visualstudio.com">code.visualstudio.com</a></p></li><li><p>Sisteminize uygun olan sürümü indirin.</p></li><li><p>İndirilen dosyayı çalıştırın ve kurulum talimatlarını takip edin.</p></li></ol><h3>Adım 2: JavaScript Eklentilerinin Kurulması</h3><p>VSCode içinde JavaScript kodu yazabilmeniz için bazı eklentiler kurmanız önerilir.</p><ol><li><p>VSCode’u açın.</p></li><li><p>Sol taraftaki menüde bulunan “Extensions” sekmesine tıklayın (ya da <code>Ctrl+Shift+X</code> kısayolunu kullanın).</p></li><li><p>Arama çubuğuna “JavaScript” yazın ve önerilen eklentileri bulun. Özellikle “ESLint”, “Prettier - Code formatter” ve “JavaScript (ES6) code snippets” eklentileri işinize yarayacaktır.</p></li><li><p>“Install” butonuna tıklayarak bu eklentileri kurun.</p></li></ol><h3>Adım 3: İlk JavaScript Programınızı Yazın ve Tarayıcıda Çalıştırın</h3><p>JavaScript kodunuzu tarayıcıda çalıştırmak için bir HTML dosyası oluşturabilirsiniz.</p><ol><li><p>VSCode’da yeni bir HTML dosyası oluşturun ve aşağıdaki kodu ekleyin:</p><pre><code class="language-html">&lt;!DOCTYPE html&gt;
&lt;html lang="en"&gt;
&lt;head&gt;
    &lt;meta charset="UTF-8"&gt;
    &lt;meta name="viewport" content="width=device-width, initial-scale=1.0"&gt;
    &lt;title&gt;JavaScript ile Merhaba Dünya&lt;/title&gt;
&lt;/head&gt;
&lt;body&gt;
    &lt;h1&gt;Merhaba, dünya!&lt;/h1&gt;
    &lt;script&gt;
        console.log("Merhaba, dünya!");
        alert("Merhaba, dünya!");
    &lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;</code></pre></li><li><p>Dosyayı <code>index.html</code> olarak kaydedin.</p></li><li><p>Kaydettiğiniz dosyayı tarayıcınızda açın.</p></li><li><p>Tarayıcı konsolunda <code>console.log</code> çıktısını ve sayfada bir uyarı mesajı görmelisiniz.</p></li></ol><h3>Adım 4: Node.js’in Kurulması</h3><p>Şimdi de Node.js’i bilgisayarınıza kurmalısınız. Node.js, JavaScript çalıştırmak için gereken bir ortamdır ve aynı zamanda npm (Node Package Manager) ile birlikte gelir.</p><ol><li><p>Node.js’in resmi web sitesine gidin: <a target="_blank" rel="noopener noreferrer nofollow" href="http://nodejs.org">nodejs.org</a></p></li><li><p>“Downloads” sekmesine tıklayın.</p></li><li><p>Sisteminize uygun olan Node.js sürümünü indirin. (Yeni başlıyorsanız, LTS (Long Term Support) sürümünü öneririz.)</p></li><li><p>İndirilen dosyayı çalıştırın ve kurulum talimatlarını takip edin.</p></li></ol><h3>Adım 5: Node.js Yorumlayıcısının Seçilmesi</h3><p>VSCode içinde JavaScript kodu çalıştırabilmek için Node.js yorumlayıcısını kullanabilirsiniz.</p><ol><li><p>VSCode’u açın ve yeni bir JavaScript dosyası oluşturun.</p></li><li><p>Terminali açmak için `Ctrl+ tuşlarına basın.</p></li><li><p>Terminalde <code>node -v</code> komutunu çalıştırarak Node.js’in düzgün kurulup kurulmadığını kontrol edin. Bu komut, yüklü olan Node.js sürümünü gösterecektir.</p></li></ol><h3>Adım 6: İlk JavaScript Programınızı Yazın ve Node.js ile Çalıştırın</h3><p>Artık Node.js’i kullanarak ilk JavaScript programınızı çalıştırabilirsiniz.</p><ol><li><p>VSCode’da yeni bir JavaScript dosyası oluşturun ve aşağıdaki kodu yazın:</p><pre><code class="language-jsx">console.log("Merhaba, dünya!");</code></pre></li><li><p>Dosyayı <code>app.js</code> olarak kaydedin.</p></li><li><p>Terminalde dosyanızın bulunduğu dizine gidin ve <code>node app.js</code> komutunu çalıştırarak kodu çalıştırın.</p></li><li><p>Terminal bölmesinde programın çıktısını görmelisiniz.</p></li></ol><p>Tebrikler! Artık VSCode kullanarak JavaScript programları yazabilir ve çalıştırabilirsiniz. Bu ortam, kod yazmanızı kolaylaştıracak birçok araç ve özellik sunar. İlerledikçe, daha fazla eklenti kurarak ve ayarları özelleştirerek geliştirme ortamınızı daha da geliştirebilirsiniz. İyi kodlamalar!</p>

VSCode ile JavaScript Kurulumu: Adım Adım Rehber

<p>JavaScript, geniş uygulama alanlarına sahip, esnek ve güçlü bir programlama dilidir. Yaygın olarak kullanılan bu dil, web geliştirmeden oyun geliştirmeye, mobil uygulamalardan sunucu tarafı programlamaya kadar birçok farklı alanda kullanılabilir. Bu makalede, JavaScript ile yapılabilecek bazı popüler uygulamaları inceleyeceğiz.</p><h3>Web Geliştirme</h3><p>JavaScript, React, Angular ve Vue.js gibi popüler framework ve kütüphaneler sayesinde web uygulamaları geliştirmek için tercih edilen dillerden biridir. Bu araçlar, dinamik ve etkileşimli kullanıcı arayüzleri oluşturmanıza yardımcı olur. Ayrıca, JavaScript'in Node.js gibi sunucu tarafı teknolojileri ile kullanılması, tam yığın (full stack) web geliştirmeyi mümkün kılar.</p><h3>Veri Analizi ve Bilim</h3><p>JavaScript, veri analizi ve bilimsel hesaplamalar için de kullanılabilir. D3.js gibi kütüphaneler, veri görselleştirme işlemlerini kolaylaştırırken, math.js gibi kütüphaneler matematiksel hesaplamalar için kullanılabilir. Ayrıca, Jupyter Notebook benzeri etkileşimli kodlama ortamları olan Observable ile veri analizi projeleri gerçekleştirebilirsiniz.</p><h3>Makine Öğrenimi ve Yapay Zeka</h3><p>JavaScript, TensorFlow.js ve Brain.js gibi kütüphaneleri sayesinde makine öğrenimi ve yapay zeka projelerinde de kullanılmaktadır. Bu kütüphaneler, geliştiricilere derin öğrenme modelleri oluşturma ve eğitme imkanı tanır. JavaScript, aynı zamanda ml5.js gibi makine öğrenimi algoritmalarını kolayca uygulayabileceğiniz kütüphanelere de sahiptir.</p><h3>Oyun Geliştirme</h3><p>JavaScript, Phaser ve Three.js gibi kütüphaneleri ile oyun geliştirme için de yaygın olarak kullanılır. Phaser, 2D oyunlar geliştirmek için kapsamlı bir çerçeve sunarken, Three.js, 3D grafikler ve animasyonlar oluşturmanıza olanak tanır. Bu kütüphaneler, oyun döngüsünü, grafikleri, sesleri ve kullanıcı girdilerini kolayca yönetmenizi sağlar.</p><h3>Otomasyon ve Betik Yazma</h3><p>JavaScript, otomasyon betikleri (script) yazmak için mükemmel bir dildir. Basit ve anlaşılır sözdizimi sayesinde, geliştiriciler rutin görevleri otomatikleştirmek ve sistem yönetimi işlemlerini kolaylaştırmak için JavaScript betikleri yazabilirler. Özellikle Node.js ile sunucu tarafı otomasyon işlemleri yaygındır.</p><h3>Mobil Uygulamalar</h3><p>JavaScript, React Native ve Ionic gibi çerçeveler sayesinde mobil uygulama geliştirme için de kullanılabilir. Bu çerçeveler, hem iOS hem de Android platformlarında çalışan çapraz platform mobil uygulamalar oluşturmanıza olanak tanır. Ayrıca, NativeScript gibi araçlar ile yerel (native) mobil uygulamalar da geliştirilebilir.</p><h3>Masaüstü Uygulamalar</h3><p>JavaScript, Electron.js gibi kütüphaneleri ile masaüstü uygulamalar geliştirmek için de kullanılabilir. Electron.js, web teknolojilerini kullanarak çapraz platform masaüstü uygulamaları oluşturmanıza olanak tanır. Bu sayede, HTML, CSS ve JavaScript kullanarak Windows, macOS ve Linux için uygulamalar geliştirebilirsiniz.</p><h3>Gömülü Sistemler ve İnternet Nesneleri (IoT)</h3><p>JavaScript, Johnny-Five ve Espruino gibi kütüphaneler sayesinde gömülü sistemler ve İnternet Nesneleri (IoT) projelerinde de kullanılabilir. Bu kütüphaneler, mikrodenetleyiciler üzerinde çalışarak, sensörler ve diğer donanım bileşenleri ile etkileşime girmenizi sağlar. Node.js ile birleştiğinde, güçlü ve esnek IoT çözümleri oluşturabilirsiniz.</p><h3>Sonuç</h3><p>JavaScript, geniş bir uygulama yelpazesi sunan esnek ve güçlü bir programlama dilidir. Web geliştirmeden mobil uygulamalara, oyun geliştirmeden otomasyona kadar birçok alanda kullanılabilir. Bu, JavaScript'in özellikle farklı disiplinlerdeki projeler üzerinde çalışan geliştiriciler için cazip bir seçenek haline getirir. JavaScript ile başlamak istiyorsanız, geniş çevrimiçi kaynaklardan ve topluluk destekli öğrenme platformlarından yararlanabilirsiniz. JavaScript, programlama dünyasına adım atmaya karar verdiğinizde sizi karşılayacak zengin özelliklere sahip bir dil olacaktır.</p>

JavaScript ile Neler Yapabilirsiniz?

<p>JavaScript, 1995 yılında Brendan Eich tarafından oluşturulan ve yüksek seviyeli, yorumlanabilir, dinamik bir programlama dilidir. Başlangıçta web tarayıcıları için geliştirilmiş olup, günümüzde hem istemci tarafında hem de sunucu tarafında yaygın olarak kullanılmaktadır. Bu makalede, JavaScript’in temel özelliklerini, avantajlarını ve diğer programlama dillerinden farklarını inceleyeceğiz.</p><h3>JavaScript’in Temel Özellikleri</h3><p><strong>Yüksek Seviyeli:</strong> JavaScript, geliştiricinin donanım seviyesi detayları hakkında endişelenmesine gerek kalmadan program yazmasına olanak tanır. Bu, kod yazmayı ve okumayı daha kolay hale getirir.</p><p><strong>Yorumlanabilir:</strong> JavaScript kodu, tarayıcı veya Node.js gibi bir ortamda çalıştırıldığında doğrudan yorumlanır. Bu, hızlı bir prototip oluşturmayı ve hata ayıklamayı kolaylaştırır.</p><p><strong>Dinamik:</strong> JavaScript, dinamik veri türlerine sahiptir ve değişkenlerin türlerini belirlemeye gerek kalmadan kullanıcılara esneklik sağlar.</p><p><strong>Nesne Yönelimli:</strong> JavaScript, nesne yönelimli programlama (OOP) paradigmasını destekler, bu da kodun modüler ve yeniden kullanılabilir olmasını sağlar.</p><p><strong>Geniş Ekosistem:</strong> JavaScript, npm gibi büyük bir paket yöneticisine ve zengin bir kütüphane ve çerçeve ekosistemine sahiptir. Bu, geliştiricilerin birçok farklı görevi hızlı ve kolay bir şekilde gerçekleştirmelerini sağlar.</p><h3>JavaScript’in Avantajları</h3><p><strong>Kolay Öğrenme:</strong> JavaScript’in sözdizimi, diğer programlama dillerine göre daha basit ve anlaşılırdır. Bu, yeni başlayanların hızlı bir şekilde üretken olmalarını sağlar.</p><p><strong>Hızlı Geliştirme:</strong> JavaScript, hızlı prototip oluşturma ve uygulama geliştirme sürecini hızlandıran birçok özellik sunar.</p><p><strong>Çok Yönlülük:</strong> JavaScript, web geliştirme, mobil uygulama geliştirme, masaüstü uygulama geliştirme ve daha birçok alanda kullanılabilir.</p><p><strong>Geniş Topluluk Desteği:</strong> JavaScript’in geniş ve aktif bir kullanıcı topluluğu vardır. Bu, sorunlarınıza çabucak çözüm bulmanıza, öğrenme kaynaklarına erişmenize ve kod örneklerini paylaşmanıza olanak tanır.</p><h3>JavaScript ve Diğer Programlama Dilleri Arasındaki Farklar</h3><p><strong>Sözdizimi:</strong> JavaScript, diğer dillerle karşılaştırıldığında daha basit ve okunabilir bir sözdizimine sahiptir. Örneğin, Python gibi dillerde girintiler kullanılırken, JavaScript’te süslü parantezler kullanılır.</p><p><strong>Hafıza Yönetimi:</strong> JavaScript, otomatik hafıza yönetimi ve bir çöp toplama mekanizması sunar. Bu, geliştiricinin hafıza yönetimi ile ilgili endişelenmesine gerek kalmadan çalışmasına olanak tanır.</p><p><strong>Çalışma Hızı:</strong> JavaScript, yorumlanabilir bir dil olduğu için genellikle C veya Java gibi derlenmiş dillere göre daha yavaştır. Ancak, modern JavaScript motorları ve optimizasyon teknikleri bu farkı minimize eder.</p><p><strong>Taşınabilirlik:</strong> JavaScript, platform bağımsızdır ve birçok işletim sistemi ve tarayıcı üzerinde çalışabilir. Node.js sayesinde sunucu tarafında da kullanılabilir ve bu, taşınabilirliğini artırır.</p><h3>Sonuç</h3><p>JavaScript, öğrenmesi kolay, geniş bir uygulama alanına sahip ve hızlı geliştirme süreçleri sunan bir programlama dilidir. Temiz ve anlaşılır sözdizimi, geniş kütüphane desteği ve aktif topluluk desteği ile özellikle web geliştirme için mükemmel bir seçenektir. Diğer dillere göre bazı performans ve taşınabilirlik farklılıkları olabilir, ancak bu farklar birçok uygulama için önemsizdir ve JavaScript’in avantajları genellikle bu dezavantajları aşar.</p><p>JavaScript ile ilgili daha fazla bilgi edinmek ve bu dilde programlamaya başlamak istiyorsanız, çeşitli çevrimiçi kaynaklar ve dökümantasyonlar mevcuttur. Yolculuğunuzda başarılar dileriz!</p>

JavaScript’e Giriş: JavaScript Nedir ve Diğer Programlama Dillerinden Farkları

<p>Node.js, tek iş parçacıklı yapısı ile bilinir ve bu yapı, giriş/çıkış (I/O) işlemlerinde yüksek performans sağlar. Ancak CPU yoğunluklu işlemler söz konusu olduğunda, bu tek iş parçacıklı model bazı sınırlamalarla karşılaşabilir. Daha önceki videoda cluster modülünü ele almıştık, bu makalede ise Worker Threads modülünü inceleyeceğiz. Worker Threads modülü, JavaScript kodunun paralel olarak yürütülmesini sağlayarak uygulamanın performansını artırır.</p><h3>Cluster Modülü ile Worker Threads Modülünün Karşılaştırılması</h3><p>Cluster modülü, Node.js'in birden fazla örneğini çalıştırarak iş yükünü dağıtmaya yarar. Her bir örnek, bağımsız bir V8 motoru, olay döngüsü ve bellek alanına sahiptir. Bu, özellikle uygulamanın farklı parçalarının birbirinden tamamen izole edilmesi gerektiğinde kullanışlıdır.</p><p>Worker Threads modülü ise, tek bir Node.js örneğinde birden fazla iş parçacığı çalıştırılmasına olanak tanır. Bu modül, işlem izolasyonunun gerekmediği durumlarda kullanılır ve ayrı V8 örneklerine, olay döngülerine ve bellek alanlarına ihtiyaç duymaz.</p><h3>Worker Threads Modülünün Kullanımı</h3><p>Worker Threads modülünün nasıl çalıştığını anlamak için bir örnek uygulama üzerinden gidelim.</p><h3>Ana İş Parçacığı Kodu (main-thread.js)</h3><p>Öncelikle, <code>main-thread.js</code> dosyasını oluşturalım ve temel bir HTTP sunucusu kurulumunu yapalım. Bu sunucu iki rota ile çalışacaktır: ana sayfa (<code>/</code>) ve yavaş sayfa (<code>/slow-page</code>).</p><pre><code class="language-jsx">const http = require('http');

const server = http.createServer((req, res) =&gt; {
    if (req.url === '/') {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Home Page');
    } else if (req.url === '/slow-page') {
        let j = 0;
        for (let i = 0; i &lt; 1e7; i++) {
            j++;
        }
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end(`Slow Page ${j}`);
    }
});

server.listen(8000, () =&gt; {
    console.log('Server listening on port 8000');
});</code></pre><p>Bu örnekte, <code>/slow-page</code> rotası uzun süren bir for döngüsü içerir. Eğer <code>/slow-page</code> yüklenirken aynı anda <code>/</code> rotasına bir istek yaparsak, ikinci istek de yavaş yanıt verecektir çünkü tek iş parçacığı bu uzun süren işlemle meşgul olacaktır.</p><h3>Worker Threads Modülü ile İyileştirilmiş Kod</h3><p>Şimdi aynı sunucuyu Worker Threads modülü kullanarak geliştirelim.</p><p>Öncelikle <code>main-thread.js</code> dosyasını güncelleyelim:</p><pre><code class="language-jsx">const { Worker } = require('worker_threads');
const http = require('http');

const server = http.createServer((req, res) =&gt; {
    if (req.url === '/') {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Home Page');
    } else if (req.url === '/slow-page') {
        const worker = new Worker('./worker-thread.js');
        worker.on('message', (j) =&gt; {
            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end(`Slow Page ${j}`);
        });
    }
});

server.listen(8000, () =&gt; {
    console.log('Server listening on port 8000');
});</code></pre><p>Ardından, iş yükünü taşıyacak olan <code>worker-thread.js</code> dosyasını oluşturalım:</p><pre><code class="language-jsx">const { parentPort } = require('worker_threads');

let j = 0;
for (let i = 0; i &lt; 1e7; i++) {
    j++;
}
parentPort.postMessage(j);</code></pre><p>Bu kodda, uzun süren işlem <code>worker-thread.js</code> dosyasına taşınmış ve ana iş parçacığı, işçiden (<code>worker</code>) gelen mesajı dinleyerek yanıtı döndürmüştür.</p><h3>Worker Threads Modülünün Avantajları</h3><ol><li><p><strong>Paralel İşleme</strong>: Worker Threads modülü, JavaScript kodunun paralel olarak yürütülmesini sağlar. Bu, CPU yoğunluklu işlemler sırasında uygulamanın performansını önemli ölçüde artırır.</p></li><li><p><strong>Tek Node.js Örneği</strong>: Cluster modülünün aksine, Worker Threads modülü tek bir Node.js örneği içinde çalışır ve ayrı V8 örneklerine ihtiyaç duymaz. Bu, bellek kullanımını optimize eder ve işlemler arası veri paylaşımını kolaylaştırır.</p></li><li><p><strong>Kullanım Kolaylığı</strong>: Worker Threads modülü, mevcut Node.js kodunun büyük bir kısmını değiştirmeden paralel işleme geçiş yapmayı kolaylaştırır.</p></li></ol><h3>Worker Threads Modülünün Kullanım Alanları</h3><p>Worker Threads modülü, çeşitli CPU yoğunluklu işlemler için idealdir. Örneğin:</p><ul><li><p><strong>Görüntü ve Video İşleme</strong>: Büyük görüntülerin yeniden boyutlandırılması veya videoların işlenmesi gibi işlemler.</p></li><li><p><strong>Dosya Şifreleme</strong>: Dosya şifreleme ve çözme işlemleri.</p></li><li><p><strong>Matematiksel Hesaplamalar</strong>: Büyük veri setlerinin işlenmesi ve karmaşık matematiksel hesaplamalar.</p></li></ul><h3>Sonuç</h3><p>Node.js'in Worker Threads modülü, tek iş parçacıklı modelin sınırlarını aşarak CPU yoğunluklu işlemler için etkili bir çözüm sunar. Bu modül ile JavaScript kodunu paralel olarak çalıştırabilir ve uygulamanızın performansını artırabilirsiniz. Worker Threads modülü hakkında daha fazla bilgi edinmek için resmi <a target="" rel="noopener noreferrer nofollow" href="https://nodejs.org/api/worker_threads.html">Node.js belgelerine</a> göz atmanızı tavsiye ederim.</p><p>Bu makale, Worker Threads modülünün temellerini ve kullanım örneklerini kapsar. Daha ileri düzeyde kullanım ve optimizasyon teknikleri için modülün dökümantasyonunu incelemeniz faydalı olacaktır. Node.js ile büyük ve karmaşık uygulamalar geliştirirken, Worker Threads modülünün sunduğu avantajlardan faydalanmanız, performans ve kullanıcı deneyimini artırmanıza yardımcı olacaktır.</p>

Node.js Worker Threads Modülü: Performans ve Paralel İşleme için Güçlü Bir

<p>Node.js, asenkron yapısı ve tek iş parçacıklı çalışma modeli sayesinde yüksek performanslı uygulamalar geliştirmek için ideal bir platformdur. Ancak, CPU yoğunluklu işlemler söz konusu olduğunda bu tek iş parçacıklı model bazı sınırlamalara sahiptir. Bu makalede, Node.js'in bu sınırlamaları aşmak için sunduğu cluster modülünü detaylı bir şekilde inceleyeceğiz.</p><h3>Tek İş Parçacıklı Mimarinin Sınırlamaları</h3><p>Node.js tek iş parçacıklı bir çalışma modeli kullanır. Bu, Node.js'in sadece bir CPU çekirdeğini kullanabileceği anlamına gelir. I/O operasyonları (dosya okuma/yazma, ağ istekleri gibi) için bu model son derece verimlidir çünkü bu tür işlemler genellikle CPU'yu meşgul etmez. Ancak, uzun süren ve CPU yoğunluklu işlemler (örneğin, büyük veri setlerinin işlenmesi, karmaşık hesaplamalar) söz konusu olduğunda performans sorunları ortaya çıkabilir. Tek bir iş parçacığı bu tür işlemlerle meşgul olduğunda, diğer istekler gecikebilir ve uygulamanın genel performansı düşebilir.</p><h3>Cluster Modülünün Tanıtımı</h3><p>Node.js, bu performans sorunlarını aşmak için cluster modülünü tanıtmıştır. Cluster modülü, aynı anda çalışan birden fazla child process (çalışanlar) oluşturmayı sağlar. Bu çalışanlar aynı uygulamanın birden fazla kopyasını çalıştırır ve gelen istekleri paylaşarak işlem yükünü dengeler. Her çalışan, kendi olay döngüsüne, belleğine ve V8 JavaScript motoru örneğine sahiptir.</p><h5><strong>Cluster Modülünün Temel Prensipleri</strong></h5><ol><li><p><strong>Master ve Worker Süreçleri</strong>: Cluster modülü kullanıldığında, Node.js uygulaması bir master süreç olarak başlatılır. Bu master süreç, çalışan süreçleri oluşturur ve yönetir. Master süreç, çalışanların başlatılması, durdurulması ve yeniden başlatılması gibi görevlerden sorumludur ancak uygulama kodunu çalıştırmaz.</p></li><li><p><strong>İş Yükü Dağıtımı</strong>: Her çalışan süreç, uygulamanın bir kopyasını çalıştırır ve gelen istekleri işler. Bu sayede, iş yükü birden fazla çalışan süreç arasında dağıtılır ve performans iyileştirilir. Örneğin, bir çalışan uzun süren bir işlemi yürütürken diğer çalışanlar yeni gelen istekleri işleyebilir.</p></li><li><p><strong>Aynı Portu Paylaşma</strong>: Tüm çalışan süreçler aynı sunucu portunu paylaşır. Bu, master sürecin iş yükünü otomatik olarak çalışan süreçler arasında dağıtmasını sağlar.</p></li></ol><h4>Cluster Modülü ile Örnek Uygulama</h4><p>Cluster modülünün nasıl çalıştığını daha iyi anlamak için basit bir örnek uygulama oluşturacağız. Bu uygulama, cluster modülünü kullanmadan önce ve kullandıktan sonra performans karşılaştırması yapacak.</p><h5><strong>Cluster Modülü Kullanmadan Basit HTTP Sunucusu</strong></h5><p>Öncelikle, cluster modülünü kullanmadan basit bir HTTP sunucusu oluşturalım:</p><pre><code>const http = require('http');

const server = http.createServer((req, res) =&gt; {
    if (req.url === '/') {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Home Page');
    } else if (req.url === '/slow-page') {
        // Uzun süren bir işlem simülasyonu
        for (let i = 0; i &lt; 1e7; i++);
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Slow Page');
    }
});

server.listen(8000, () =&gt; {
    console.log('Server listening on port 8000');
});</code></pre><p>Bu örnekte, <code>/</code> rotası hızlı bir yanıt verirken, <code>/slow-page</code> rotası uzun süren bir for döngüsü nedeniyle yavaş yanıt verir. Eğer <code>/slow-page</code> yüklenirken aynı anda <code>/</code> rotasına bir istek yaparsak, ikinci istek de yavaş yanıt verecektir çünkü tek iş parçacığı bu uzun süren işlemle meşgul olacaktır.</p><h5><strong>Cluster Modülü ile Geliştirilmiş HTTP Sunucusu</strong></h5><p>Şimdi aynı sunucuyu cluster modülü kullanarak geliştirelim:</p><pre><code>const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
    console.log(`Master ${process.pid} is running`);

    // Çekirdek sayısı kadar işçi süreç oluşturma
    for (let i = 0; i &lt; numCPUs; i++) {
        cluster.fork();
    }

    cluster.on('exit', (worker, code, signal) =&gt; {
        console.log(`Worker ${worker.process.pid} died`);
    });
} else {
    // İşçi süreçlerin çalıştırdığı kod
    const server = http.createServer((req, res) =&gt; {
        if (req.url === '/') {
            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end('Home Page');
        } else if (req.url === '/slow-page') {
            for (let i = 0; i &lt; 1e7; i++);
            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end('Slow Page');
        }
    });

    server.listen(8000, () =&gt; {
        console.log(`Worker ${process.pid} started`);
    });
}</code></pre><p>Bu kodda, master süreç CPU çekirdek sayısı kadar işçi süreç oluşturur. Her işçi süreç, gelen istekleri işleyerek performansı iyileştirir. Aynı anda hem <code>/</code> rotasına hem de <code>/slow-page</code> rotasına yapılan isteklerin her biri farklı işçiler tarafından işlendiği için birbirini bloke etmez.</p><h3>Optimum İşçi Sayısını Belirleme</h3><p>İşçi süreçlerin sayısını belirlerken, sistemdeki CPU çekirdek sayısı dikkate alınmalıdır. Çok fazla işçi oluşturmak, sistemde aşırı yüklenmeye ve performans düşüşüne yol açabilir. <code>os</code> modülünü kullanarak sistemdeki CPU çekirdek sayısını öğrenebiliriz:</p><pre><code>const os = require('os');
console.log(os.cpus().length);</code></pre><p>Bu kod, sistemdeki CPU çekirdek sayısını konsola yazdıracaktır. Örneğin, 8 çekirdekli bir sistemde bu değer 8 olacaktır.</p><h3>pm2 ile Cluster Yönetimi</h3><p>Cluster modülünü manuel olarak yönetmek yerine, pm2 gibi bir süreç yöneticisi kullanarak işleri kolaylaştırabiliriz. pm2, uygulamanızı cluster modunda çalıştırmanızı ve optimum işçi sayısını otomatik olarak belirlemenizi sağlar.</p><p>pm2'yi global olarak yüklemek için şu komutu kullanabilirsiniz:</p><pre><code>sudo npm install -g pm2</code></pre><p>Ardından, uygulamanızı pm2 ile cluster modunda çalıştırabilirsiniz:</p><pre><code>pm2 start cluster.js -i 0</code></pre><p>Buradaki <code>-i 0</code> parametresi, pm2'nin en uygun işçi sayısını otomatik olarak belirlemesini sağlar. pm2 ayrıca süreçleri izleme, yeniden başlatma ve durdurma gibi işlevler de sunar.</p><h3>Sonuç</h3><p>Node.js'in cluster modülü, tek iş parçacıklı modelin sınırlamalarını aşmak için güçlü bir araçtır. Uzun süren ve CPU yoğunluklu işlemler sırasında uygulamanızın performansını iyileştirir. Cluster modülü ile uygulamanızın iş yükünü birden fazla süreç arasında dağıtarak daha ölçeklenebilir ve yüksek performanslı uygulamalar geliştirebilirsiniz. Ayrıca, pm2 gibi araçlar kullanarak süreç yönetimini otomatikleştirip daha da kolaylaştırabilirsiniz. Node.js ile büyük ve karmaşık uygulamalar geliştirirken cluster modülünün sunduğu avantajlardan faydalanmanız, performans ve kullanıcı deneyimini artırmanıza yardımcı olacaktır.</p>

Node.js Cluster Modülü: Performans ve Ölçeklenebilirlik için Güçlü Bir Araç

<p>Node.js kullanarak CLI (Command Line Interface) araçları oluşturmak, geliştiricilerin iş akışlarını otomatikleştirmeleri ve belirli görevleri hızlı bir şekilde gerçekleştirmeleri için oldukça kullanışlıdır. Bu makalede, Node.js kullanarak etkileşimli bir CLI aracının nasıl oluşturulacağını adım adım öğreneceğiz. Amacımız, kullanıcı dostu bir CLI aracı geliştirerek kullanıcıların komut satırında manuel giriş yapmalarını ve hatırlamalarını gerektiren süreçleri basitleştirmektir.</p><h3>1. CLI Araçlarının Temelleri</h3><p>CLI, yani Komut Satırı Arayüzü, terminal veya komut satırında çalıştırılan programlardır. Kullanıcı, belirli komutlar ve seçenekler girerek programı çalıştırabilir. CLI araçları genellikle hızlı ve etkilidir, çünkü grafiksel kullanıcı arayüzleri (GUI) kullanmaya gerek kalmadan doğrudan komutlarla etkileşime girerler.</p><h3>2. CLI Aracını Etkileşimli Hale Getirmek</h3><p>Temel bir CLI aracı, kullanıcıdan belirli seçenekler alarak çalışır. Örneğin, bir kullanıcı veritabanı uygulaması düşünelim. Kullanıcı, belirli bir kullanıcı kimliği girerek o kullanıcının bilgilerini almak isteyebilir. Normalde bu, şu şekilde çalışır:</p><pre><code>node app.js --userId 1</code></pre><p>Bu yaklaşım, kullanıcıların doğru seçenekleri ve formatı bilmesini gerektirir. Bunu daha kullanıcı dostu hale getirmek için CLI aracımızı etkileşimli hale getirebiliriz. Böylece, kullanıcı komutu çalıştırdıktan sonra program ona hangi bilgileri girmesi gerektiğini sorar.</p><h3>3. Inquirer Paketi ile Etkileşim Eklemek</h3><p>Node.js ile etkileşimli CLI araçları geliştirmek için çeşitli npm paketleri mevcuttur. Bu örnekte, popüler bir paket olan Inquirer'ı kullanacağız. Inquirer, kullanıcıdan giriş almak için etkileşimli komut satırı soruları sunar.</p><h5><strong>Adım 1: Inquirer Paketini Kurma</strong></h5><p>Öncelikle, Inquirer paketini projemize eklememiz gerekiyor. Terminalde aşağıdaki komutu çalıştırarak Inquirer paketini kurabiliriz:</p><pre><code>npm install Inquirer@8.2.5</code></pre><p>Versiyon 9 sadece ES modüllerle çalıştığı için, CommonJS modül formatını da destekleyen versiyon 8.2.5'i kullanıyoruz.</p><h5><strong>Adım 2: Inquirer Paketini İçe Aktarma ve Kullanma</strong></h5><p><code>index.js</code> dosyamızın başında Inquirer paketini içe aktarıyoruz:</p><pre><code>const Inquirer = require('Inquirer');</code></pre><h5><strong>Adım 3: Etkileşimli Kullanıcı Girdisi ve API Çağrısı</strong></h5><p>Etkileşimli CLI aracımızda, kullanıcıdan bir kullanıcı kimliği alacağız ve bu kimliği kullanarak bir API'dan kullanıcı bilgilerini çekeceğiz. API çağrıları için <code>node-fetch</code> paketini kullanacağız. Terminalde <code>npm install node-fetch</code> komutunu çalıştırarak <code>node-fetch</code> paketini kuruyoruz.</p><pre><code>const fetch = require('node-fetch');

const printUserInfo = async (userId) =&gt; {
    const response = await fetch(`https://jsonplaceholder.typicode.com/users/${userId}`);
    const userData = await response.json();
    const userInfo = {
        name: userData.name,
        username: userData.username,
        email: userData.email,
        phone: userData.phone,
        website: userData.website
    };
    console.log(userInfo);
};

const prompt = Inquirer.createPromptModule();

prompt([{
    type: 'input',
    name: 'userId',
    message: 'Enter a user ID to view their information:',
}]).then(answers =&gt; {
    const userId = answers.userId;
    printUserInfo(userId);
});</code></pre><p>Bu kod parçası, kullanıcıdan bir kullanıcı kimliği girmesini isteyen bir soru oluşturur ve kullanıcının cevabını işleyerek <code>printUserInfo</code> fonksiyonuna geçirir. <code>printUserInfo</code> fonksiyonu, verilen kimlik ile bir API çağrısı yapar ve kullanıcı bilgilerini konsola yazdırır.</p><h4>4. CLI Aracının Çalıştırılması</h4><p>Etkileşimli CLI aracımızı çalıştırmak için terminalde şu komutu kullanabiliriz:</p><pre><code>node index.js</code></pre><p>Bu komut, CLI aracını başlatır ve kullanıcıdan bir kullanıcı kimliği girmesini isteyen bir soru görüntüler. Kullanıcı bir kimlik girdiğinde, ilgili kullanıcı bilgileri API'dan alınarak terminalde listelenir.</p><h4>5. CLI Araçlarının Önemi ve Geliştirme İpuçları</h4><p>CLI araçları, geliştiricilerin ve sistem yöneticilerinin günlük iş akışlarını otomatikleştirmeleri için güçlü araçlardır. Etkileşimli CLI araçları, kullanıcı deneyimini iyileştirerek kullanım kolaylığı sağlar. İşte CLI araçları geliştirirken dikkate almanız gereken bazı ipuçları:</p><ul><li><p><strong>Modülerlik</strong>: CLI aracınızı modüler bir yapıda tasarlayın. Bu, kodunuzu daha okunabilir ve sürdürülebilir hale getirir.</p></li><li><p><strong>Kullanıcı Dostu Sorular</strong>: Kullanıcıdan alınacak girdileri net ve anlaşılır şekilde tasarlayın. Kullanıcının ne yapması gerektiğini anlaması kolay olmalıdır.</p></li><li><p><strong>Hata Yönetimi</strong>: Kullanıcının yanlış giriş yapması durumunda uygun hata mesajları gösterin ve tekrar giriş yapmasına olanak tanıyın.</p></li><li><p><strong>Dokümantasyon</strong>: CLI aracınızın nasıl kullanılacağına dair kapsamlı bir dokümantasyon sağlayın. Bu, kullanıcıların aracı daha etkili bir şekilde kullanmasını sağlar.</p></li></ul><h3>Sonuç</h3><p>Bu makalede, Node.js kullanarak etkileşimli bir CLI aracının nasıl oluşturulacağını öğrendik. Inquirer paketi ile kullanıcıdan giriş almayı ve bu girdiyi işleyerek belirli işlemler yapmayı gördük. Ayrıca, <code>node-fetch</code> paketi ile API çağrıları yaparak dinamik veriler çekmeyi öğrendik. CLI araçları, geliştiricilerin ve kullanıcıların iş akışlarını otomatikleştirmeleri ve belirli görevleri daha hızlı gerçekleştirmeleri için çok faydalıdır. Node.js ve npm kullanarak daha gelişmiş CLI araçları geliştirmeyi keşfetmenizi öneririm. Bu süreçte, modülerlik, kullanıcı dostu tasarım ve iyi dokümantasyonun önemini unutmayın.</p>

Node.js ile Etkileşimli CLI Araçları Geliştirme

<p>Node.js kullanarak CLI (Komut Satırı Arayüzü) araçları oluşturmak, geliştiriciler için oldukça faydalıdır. Bu yazıda, temel bir CLI aracı oluşturmayı öğrenmenin ötesine geçerek, CLI aracına nasıl mantık ekleyeceğimizi ve kullanıcıdan gelen argümanları nasıl işleyeceğimizi ayrıntılı olarak ele alacağız. Özellikle, herhangi bir API anahtarı gerektirmeyen JSONPlaceholder API kullanarak belirli bir kullanıcının bilgilerini sağlayacak basit bir kullanıcı bilgi CLI aracını nasıl oluşturacağımızı inceleyeceğiz.</p><p>Önceki videomuzda, Node.js ve npm kullanarak basit bir CLI aracı oluşturmayı öğrendik. Bu araç, kullanıcı komutlarını alıp basit işlemler yapabiliyordu. Şimdi ise bu temelin üzerine eklemeler yaparak aracı daha işlevsel hale getireceğiz.</p><h3>JSONPlaceholder API Kullanımı</h3><p><strong>JSONPlaceholder API Nedir?</strong> JSONPlaceholder, sahte verilerle çalışan bir REST API'dir. Bu API, test ve prototip projeleri için idealdir ve kullanıcılar, gönderiler, yorumlar, albümler ve fotoğraflar gibi çeşitli veri türlerine erişim sağlar. API'ye bir istek göndererek, belirli bir kullanıcıya ait bilgileri içeren bir JSON yanıtı alabiliriz.</p><p><strong>API'nin Kullanımı</strong> API'yi kullanmak için herhangi bir API anahtarı gerekmiyor. Örneğin, <code>1</code> ID'li kullanıcının bilgilerini almak için şu URL kullanılabilir: <code>https://jsonplaceholder.typicode.com/users/1</code>. Bu URL, ilgili kullanıcı hakkında detaylı bilgileri içeren bir JSON döndürür.</p><h3>VS Code ile Mantığın Eklenmesi</h3><p><strong>Fonksiyon Tanımlaması</strong> İlk olarak, belirli bir kullanıcı ID'si alıp, ilgili kullanıcının bilgilerini konsola loglayan bir fonksiyon tanımlamamız gerekiyor. Bu fonksiyon, asenkron (async) olacak çünkü API çağrısı yapacak.</p><pre><code>const fetch = require('node-fetch');

const printUserInfo = async (userId) =&gt; {
    const response = await fetch(`https://jsonplaceholder.typicode.com/users/${userId}`);
    const userData = await response.json();
    const userInfo = {
        name: userData.name,
        username: userData.username,
        email: userData.email,
        phone: userData.phone,
        website: userData.website
    };
    console.log(userInfo);
};

printUserInfo(1);</code></pre><p><strong>Fonksiyonun Çalışması</strong></p><ol><li><p><code>printUserInfo</code> fonksiyonu, bir kullanıcı ID'si alır.</p></li><li><p><code>fetch</code> kullanarak API'ye bu ID'yi gönderir ve yanıtı bekler.</p></li><li><p>Yanıtı JSON formatına dönüştürür.</p></li><li><p>JSON'dan isim, kullanıcı adı, e-posta, telefon ve web sitesi gibi bilgileri çıkarır.</p></li><li><p>Bu bilgileri konsola loglar.</p></li></ol><p>Bu adımları takip ederek, <code>1</code> ID'li kullanıcının bilgilerini başarıyla konsolda görebiliriz.</p><h3>Kullanıcıdan Gelen Argümanlarla Çalışma</h3><p><strong>CLI Argümanları Geçme</strong> Şu anki kodda, kullanıcı ID'si sabit kodlanmış durumda. Bunu kullanıcıdan komut satırında alacak şekilde güncellemeliyiz. Node.js'de CLI aracına argüman geçmenin yolu, <code>process.argv</code> dizisini kullanmaktır. Bu dizi, yorumlayıcıya giden yolu, CLI komutunu ve geçilen seçenekleri içerir.</p><pre><code>console.log(process.argv);</code></pre><p>Bu kod, <code>process.argv</code> dizisini konsola loglar. Örneğin, <code>node index.js --id=1</code> komutunu çalıştırdığınızda, bu dizi şu şekilde olur:</p><ul><li><p><code>0: node yolu</code></p></li><li><p><code>1: index.js yolu</code></p></li><li><p><code>2: --id=1</code></p></li></ul><h3>Yargs Paketi ile Argümanların İşlenmesi</h3><p><strong>Yargs Paketinin Kurulumu ve Kullanımı</strong> <code>yargs</code>, CLI araçları için argüman işleme işini kolaylaştıran bir pakettir. Argümanları anahtar-değer çiftlerine dönüştürür ve bu sayede kod içinde kolayca erişilebilir hale getirir. İlk olarak, <code>yargs</code> paketini yükleyelim:</p><pre><code>npm install yargs</code></pre><p>Ardından, <code>index.js</code> dosyasına <code>yargs</code> paketini dahil edip, kullanarak kullanıcı ID'sini komut satırından alabiliriz.</p><pre><code>const yargs = require('yargs');
const argv = yargs.argv;

const printUserInfo = async (userId) =&gt; {
    const response = await fetch(`https://jsonplaceholder.typicode.com/users/${userId}`);
    const userData = await response.json();
    const userInfo = {
        name: userData.name,
        username: userData.username,
        email: userData.email,
        phone: userData.phone,
        website: userData.website
    };
    console.log(userInfo);
};

printUserInfo(argv.id);</code></pre><p><strong>CLI Komutunun Güncellenmesi ve Çalıştırılması</strong> Artık CLI komutunu şu şekilde çalıştırabiliriz: <code>node index.js --id=1</code>. Bu komut, belirli bir kullanıcı ID'sine ait bilgileri alır ve ilgili bilgileri konsola loglar.</p><p>Farklı bir kullanıcı ID'si (örneğin <code>2</code>) geçirildiğinde, bu kullanıcının bilgilerini görüntüleriz. Örneğin, <code>node index.js --id=2</code> komutu farklı bir kullanıcı verisi döndürecektir.</p><h3>Sonraki Adımlar</h3><p>Bu makalede, belirli bir kullanıcının bilgilerini sağlayacak şekilde Node.js kullanarak CLI aracımıza nasıl mantık ekleyeceğimizi ve <code>yargs</code> paketi ile kullanıcıdan gelen argümanları nasıl işleyeceğimizi öğrendik. CLI aracımız, kullanıcıdan aldığı ID'ye göre doğru verileri görüntüleyebiliyor. Bir sonraki videoda ve makalede, CLI aracımıza daha fazla etkileşim eklemeyi planlıyoruz.</p><h3>Sonuç</h3><p>Node.js ile CLI araçları oluşturmak, bu araçları işlevsel hale getirmek ve kullanıcıdan gelen argümanları işlemek oldukça faydalıdır. Bu yazıda, JSONPlaceholder API kullanarak bir kullanıcı bilgi CLI aracı oluşturduk ve bu aracın nasıl geliştirileceğini ayrıntılı olarak inceledik. CLI araçları, geliştiricilere büyük kolaylık sağlar ve bu tür araçların nasıl oluşturulacağını bilmek önemli bir beceridir.</p>

CLI Options: Komut Satırı Seçenekleri

<p>Bu makalede, Node.js kullanarak CLI (Command Line Interface) araçlarının nasıl oluşturulacağını adım adım inceleyeceğiz. CLI araçları, komut satırı üzerinden çeşitli görevleri otomatikleştirmek ve kolaylaştırmak için oldukça kullanışlıdır. Bu rehberde, basit bir CLI aracının nasıl oluşturulacağını ve kullanıma sunulacağını öğreneceksiniz.</p><h3>CLI Nedir?</h3><p><strong>CLI (Command Line Interface)</strong>, terminal veya komut satırı aracılığıyla etkileşimli olarak kullanılan bir programdır. Kullanıcılar komut yazarak bu programları çalıştırabilir ve çeşitli görevleri gerçekleştirebilirler. İki yaygın CLI aracı şunlardır:</p><ul><li><p><strong>Npm (Node Package Manager)</strong>: Node.js modüllerini yönetmek için kullanılır.</p></li><li><p><strong>Git</strong>: Sürüm kontrol sistemi olarak yazılım projelerini yönetmek için kullanılır.</p></li></ul><h3>GUI Nedir?</h3><p><strong>GUI (Graphical User Interface)</strong>, grafiksel kullanıcı arayüzü anlamına gelir ve kullanıcıların görsel bileşenler (düğmeler, pencereler, simgeler) aracılığıyla programlarla etkileşimde bulunmasına olanak tanır. Kullanıcılar, fare ve klavye gibi giriş cihazlarıyla bu bileşenleri kullanarak programları kontrol edebilirler. Örnekler arasında Windows, macOS ve çoğu mobil uygulama bulunur.</p><h3>CLI ve GUI Arasındaki Farklar</h3><p><strong>Kullanıcı Etkileşimi</strong>:</p><ul><li><p><strong>CLI</strong>: Kullanıcılar komut yazarak programlarla etkileşime girer. Bu, daha fazla teknik bilgi gerektirebilir, ancak aynı zamanda daha güçlü ve esnek komutlar sağlar.</p></li><li><p><strong>GUI</strong>: Kullanıcılar görsel bileşenlerle etkileşime girer. Bu, genellikle daha sezgisel ve kullanıcı dostudur, ancak bazı ileri düzey görevler GUI üzerinden yapılamayabilir.</p></li></ul><p><strong>Kullanım Alanları</strong>:</p><ul><li><p><strong>CLI</strong>: Sistem yönetimi, yazılım geliştirme, otomasyon ve diğer teknik görevler için idealdir. Örneğin, sunucu yönetimi ve script yazma gibi işlemler CLI ile daha verimli yapılabilir.</p></li><li><p><strong>GUI</strong>: Genel kullanıcılar ve görsel olarak yoğun uygulamalar için uygundur. Örneğin, fotoğraf düzenleme, oyunlar ve web tarayıcıları GUI kullanarak daha rahat bir kullanıcı deneyimi sunar.</p></li></ul><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1720072131/bg-forum/u7znsf15btwtjggmdtvd.png" alt="gui vs cli "><p><strong>Performans ve Kaynak Kullanımı</strong>:</p><ul><li><p><strong>CLI</strong>: Genellikle daha hafif ve hızlıdır çünkü grafiksel bileşenler gerektirmez.</p></li><li><p><strong>GUI</strong>: Daha fazla sistem kaynağı kullanır çünkü grafiksel bileşenler ve kullanıcı etkileşimleri için daha fazla işlem gücü gerektirir.</p></li></ul><h3>Basit Bir CLI Aracı Oluşturma</h3><p>Bu bölümde, Node.js kullanarak basit bir CLI aracının nasıl oluşturulacağını öğreneceğiz. Üç temel adımda bu işlemi gerçekleştireceğiz: Npm projesi başlatma, kod yazma ve CLI paketine dönüştürme.</p><h5><strong>Adım 1: Npm Projesi Başlatma</strong></h5><ol><li><p><strong>Yeni Klasör Oluşturma</strong>: Öncelikle proje için bir klasör oluşturun. Bu örnekte klasör adını <code>my-custom-cli</code> olarak belirledik.</p><pre><code>mkdir my-custom-cli</code></pre></li><li><p><strong>Proje Klasörüne Gitme</strong>: Terminalde oluşturulan klasöre gidin.</p><pre><code>cd my-custom-cli</code></pre></li><li><p><strong>Npm Projesi Başlatma</strong>: <code>npm init --yes</code> komutu ile varsayılan değerlerle yeni bir <code>package.json</code> dosyası oluşturun.</p><pre><code>npm init --yes</code></pre></li><li><p><strong>Proje Adını Değiştirme</strong>: <code>package.json</code> dosyasında proje adını <code>bilgen-yazilim-akademi-cli</code> olarak değiştirin. Bu adımda, paketinizi npm registry'ye yüklemeyi planlıyorsanız benzersiz bir isim seçmeniz önemlidir.</p><pre><code>{
  "name": "bilgen-yazilim-akademi-cli",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" &amp;&amp; exit 1"
  },
  "author": "",
  "license": "ISC"
}</code></pre></li></ol><h5><strong>Adım 2: Kod Yazma</strong></h5><ol><li><p><strong>Yeni Dosya Oluşturma</strong>: Proje klasöründe <code>index.js</code> adında yeni bir dosya oluşturun.</p><pre><code>type nul &gt; index.js</code></pre></li><li><p><strong>Log Mesajı Ekleme</strong>: <code>index.js</code> dosyasına basit bir log mesajı ekleyin.</p><pre><code>console.log('Bilgen Yazilim Akademi CLI Aracı');</code></pre></li></ol><h5>Adım 3: CLI Paketine Dönüştürme</h5><ol><li><p><strong>Shebang Ekleme</strong>: <code>index.js</code> dosyasının en üstüne <code>#!/usr/bin/env node</code> satırını ekleyin. Bu satır, işletim sistemine bu dosyanın Node.js ile çalıştırılacağını belirtir.</p><pre><code>#!/usr/bin/env node
console.log('Bilgen Yazilim Akademi CLI Aracı');</code></pre></li><li><p><strong>Bin Alanı Ekleme</strong>: <code>package.json</code> dosyasına <code>bin</code> alanı ekleyin. Bu alan, paketin yürütülebilir bir dosya olarak nasıl kullanılacağını belirtir.</p><pre><code>{
  "name": "bilgen-yazilim-akademi-cli",
  "version": "1.0.0",
  "bin": {
    "bilgen-yazilim-akademi": "./index.js"
  },
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" &amp;&amp; exit 1"
  },
  "author": "",
  "license": "ISC"
}</code></pre></li></ol><h3>CLI Aracını Test Etme</h3><ol><li><p><strong>Global Yükleme</strong>: <code>npm install -g</code> komutu ile CLI aracını global olarak yükleyin. Windows kullanıcıları için <code>sudo</code> kullanmaya gerek yoktur.</p><pre><code>sudo npm install -g</code></pre></li><li><p><strong>CLI Aracını Çalıştırma</strong>: Yükleme tamamlandıktan sonra <code>bilgen-yazilim-akademi</code> komutunu terminalde çalıştırın. Bu komut, <code>index.js</code> dosyasındaki log mesajını görüntüler.</p><pre><code>bilgen-yazilim-akademi</code></pre></li></ol><h3>Gelecek Adımlar</h3><ol><li><p><strong>Seçenekleri Geçme</strong>: CLI aracına nasıl seçenekler geçileceği ve bu seçeneklerin nasıl işleneceği bir sonraki adımda anlatılacaktır.</p></li><li><p><strong>Etkileşim Eklemek</strong>: CLI aracına nasıl etkileşim ekleneceği ve kullanıcıdan nasıl girdi alınacağı da ilerleyen videolarda ele alınacaktır.</p></li></ol><h3>Sonuç</h3><p>Bu makalede, Node.js kullanarak basit bir CLI aracının nasıl oluşturulacağını detaylı bir şekilde inceledik. CLI araçları, geliştiricilere komut satırı üzerinden çeşitli görevleri otomatikleştirme ve yönetme imkanı sunar. Bu rehberdeki adımları takip ederek kendi CLI araçlarınızı oluşturabilir ve kullanıma sunabilirsiniz. Gelecek adımlarda, CLI aracınıza daha fazla işlevsellik ve etkileşim eklemeyi öğrenebilirsiniz.</p>

Node.js ile CLI Araçları Oluşturma

<p>Node.js geliştirme ortamında çalışırken, projelerimizin ve kodlarımızın diğer geliştiricilerle paylaşılabilir ve tekrar kullanılabilir olmasını isteriz. Bu süreçte npm (Node Package Manager), JavaScript paketlerini yönetmek ve paylaşmak için en popüler araçlardan biridir. Bu makalede, npm üzerinde nasıl bir paket yayınlayabileceğimizi adım adım öğreneceğiz.</p><h3>1. Npm Nedir?</h3><p>Npm, Node.js ekosisteminin temel taşlarından biridir. Npm, JavaScript projeleri için bağımlılıkları yönetir ve paketlerin paylaşılmasını sağlar. Bir npm paketi, tekrar kullanılabilir kod modüllerini içerir ve bu modüller projeler arasında kolayca paylaşılabilir. Npm'in başlıca özellikleri şunlardır:</p><ul><li><p><strong>Bağımlılık Yönetimi:</strong> Projelerinizde kullanılan üçüncü parti kütüphaneleri yönetir.</p></li><li><p><strong>Paket Yayınlama:</strong> Kendi oluşturduğunuz kodları npm registry üzerinde paylaşmanızı sağlar.</p></li><li><p><strong>Paket Versiyonlama:</strong> Kodların farklı versiyonlarını yönetir ve güncellemeleri takip eder.</p></li></ul><h3>2. Npm Hesabı Oluşturma ve Giriş Yapma</h3><p>Bir npm paketi yayınlamadan önce, npm üzerinde bir hesabınızın olması gerekmektedir. Hesap oluşturma ve giriş yapma işlemleri şu adımları içerir:</p><ol><li><p><strong>Npm Hesabı Oluşturma:</strong></p><ul><li><p>Npm'in resmi web sitesine (npmjs.com) gidin ve "Sign Up" butonuna tıklayın.</p></li><li><p>Kullanıcı adı, e-posta adresi ve şifre gibi bilgileri girerek hesap oluşturun.</p></li><li><p>E-posta adresinize gönderilen tek kullanımlık şifreyi girerek hesap doğrulama işlemini tamamlayın.</p></li></ul></li><li><p><strong>Npm Hesabına Giriş Yapma:</strong></p><ul><li><p>Terminal veya komut satırında <code>npm adduser</code> komutunu çalıştırın.</p></li><li><p>Kullanıcı adınızı, şifrenizi ve e-posta adresinizi girerek npm hesabınıza giriş yapın.</p></li></ul></li></ol><h3>3. Npm Paketi Hazırlama</h3><p>Npm paketinizin doğru yapılandırıldığından emin olmak için <code>package.json</code> dosyasını oluşturmanız gerekmektedir. Bu dosya, paketinizin adını, versiyonunu, ana dosyasını ve diğer metadata bilgilerini içerir. Aşağıda basit bir <code>package.json</code> örneği bulunmaktadır:</p><pre><code>{
  "name": "moment-bilgen-yazilim-akademi",
  "version": "1.0.0",
  "description": "A simple package that uses moment.js to format dates",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" &amp;&amp; exit 1"
  },
  "keywords": ["moment", "npm", "tutorial"],
  "author": "Your Name",
  "license": "ISC"
}</code></pre><h3>4. Npm Paketi Yayınlama</h3><p>Paketinizi npm registry üzerinde paylaşmak için aşağıdaki adımları izleyin:</p><ol><li><p><strong>Npm Publish Komutu:</strong></p><ul><li><p>Terminalde, projenizin ana dizininde <code>npm publish</code> komutunu çalıştırın.</p></li><li><p>Eğer herhangi bir hata almazsanız, paketiniz npm registry üzerinde yayınlanmış olacaktır.</p></li></ul></li><li><p><strong>Paketin Yayınlandığını Kontrol Etme:</strong></p><ul><li><p>Paketinizin yayınlandığını doğrulamak için <code>https://www.npmjs.com/package/moment-bilgen-yazilim-akademi</code> adresine giderek paketinizin detaylarını kontrol edebilirsiniz.</p></li></ul></li></ol><h3>5. Npm Paketinin Kullanılması</h3><p>Yayınladığınız npm paketini kullanmak için yeni bir Node.js projesi oluşturup, aşağıdaki adımları izleyin:</p><ol><li><p><strong>Yeni Proje Oluşturma:</strong></p><ul><li><p>Yeni bir klasör oluşturun ve içine <code>npm init --yes</code> komutunu çalıştırarak <code>package.json</code> dosyası oluşturun.</p></li></ul></li><li><p><strong>Paketin Kurulumu:</strong></p><ul><li><p><code>npm install moment-bilgen-yazilim-akademi</code> komutunu çalıştırarak yayınladığınız paketi projeye ekleyin.</p></li></ul></li><li><p><strong>Paketin Kullanılması:</strong></p><ul><li><p><code>index.js</code> dosyasını oluşturup aşağıdaki kodu ekleyin:</p></li></ul></li></ol><pre><code>const getCurrentDateTime = require('moment-bilgen-yazilim-akademi');

const dateTime = getCurrentDateTime();
console.log("Current Date and Time:", dateTime.fullDate);
console.log("Formatted Date (YYYY-MM-DD):", dateTime.formattedDate1);
console.log("Formatted Date (DD-MM-YYYY):", dateTime.formattedDate2);
console.log("Formatted Time:", dateTime.formattedTime);</code></pre><h3>6. Özet ve Sonuç</h3><p>Bu makalede, Node.js projeleriniz için npm üzerinde nasıl bir paket yayınlayabileceğinizi öğrendik. Adım adım npm hesabı oluşturma, paketi yapılandırma ve yayınlama sürecini ele aldık. Npm, JavaScript projelerinin yönetimini ve paylaşımını oldukça kolaylaştıran güçlü bir araçtır. Npm paketlerini etkin bir şekilde kullanarak projelerinizde tekrar kullanılabilir kod modülleri oluşturabilir ve bu modülleri toplulukla paylaşabilirsiniz.</p><p>Daha fazla bilgi ve kaynak için npm'in resmi dokümantasyonunu ziyaret edebilirsiniz: <a target="_new" rel="noopener noreferrer nofollow" href="https://docs.npmjs.com/">npm Dokümantasyon</a>.</p>

Npm Paketi Yayınlama

<p>Node.js ile çalışan geliştiriciler için <strong>npm scripts</strong> (npm komut dosyaları), projeyi yönetmenin ve tekrarlayan görevleri otomatikleştirmenin vazgeçilmez bir yoludur. Bu makalede, npm script'lerinin ne olduğu, nasıl oluşturulacağı ve nasıl kullanılacağı hakkında detaylı bilgi vereceğiz.</p><h4>npm Script Nedir?</h4><p>npm script, bir projede sık kullanılan komutları paketlemenin kullanışlı bir yoludur. Genellikle komut satırında, uygulamayla ilgili belirli işlemleri gerçekleştirmek için kullanılır. <strong>npm scripts</strong>, projenin kök dizininde bulunan <strong>package.json</strong> dosyasında tanımlanır. Bu dosya, projeye erişimi olan herkese aynı komutları kullanma imkanı tanır ve bu sayede herkesin aynı komutları aynı seçeneklerle kullanmasını sağlar.</p><h3>npm Scripts Kullanım Alanları</h3><p>npm scripts, birçok farklı amaç için kullanılabilir. Yaygın kullanım alanları şunlardır:</p><ul><li><p><strong>Projeyi Derlemek (Build Etmek)</strong>: Projenizin kaynak kodunu derleyerek çalıştırılabilir hale getirmek.</p></li><li><p><strong>Geliştirme Sunucusu Başlatmak (Dev Server)</strong>: Kodlarınızı hızlıca test edebileceğiniz bir geliştirme sunucusu başlatmak.</p></li><li><p><strong>CSS Derlemek</strong>: Sass veya Less gibi ön işlemcileri kullanarak CSS dosyalarınızı derlemek.</p></li><li><p><strong>Linting</strong>: Kodunuzun belirli stil kurallarına uygun olup olmadığını kontrol etmek.</p></li><li><p><strong>Minify İşlemi</strong>: JavaScript veya CSS dosyalarınızı küçültmek.</p></li><li><p><strong>Test Çalıştırmak</strong>: Birim testleri veya entegrasyon testlerini çalıştırmak.</p></li><li><p>Ve daha birçok işlem için kullanılabilir.</p></li></ul><h3>npm Scripts'in Çalıştırılması</h3><p>npm script'leri, <strong>npm run</strong> komutu ve ardından script adı kullanılarak çalıştırılır. Örneğin, "start" adında bir script tanımladıysanız, bunu çalıştırmak için <code>npm run start</code> komutunu kullanabilirsiniz. Bu, package.json dosyasında tanımlı olan komutları otomatik olarak çalıştırır.</p><h3>npm Script Oluşturma ve Kullanma</h3><p>Bir npm script oluşturmak ve kullanmak oldukça basittir. İşte adım adım nasıl yapılacağı:</p><ol><li><p><strong>package.json</strong> Dosyasını Açma: Projenizin kök dizininde bulunan <strong>package.json</strong> dosyasını açın. Bu dosya, proje hakkında bilgiler ve bağımlılıklar gibi çeşitli yapılandırma ayarlarını içerir.</p></li><li><p><strong>Scripts Alanı Oluşturma</strong>: Scripts alanında yeni bir script tanımlayın. Örneğin, Node uygulamanızı çalıştırmak için bir script ekleyelim:</p><pre><code>"scripts": { "start": "node index.js" }</code></pre><p>Bu script, <code>index.js</code> dosyasını çalıştıracaktır.</p></li><li><p><strong>Script'i Çalıştırma</strong>: Terminalde proje klasörünüzde iken <code>npm run start</code> komutunu çalıştırarak script'i çalıştırabilirsiniz. Bu komut, <code>index.js</code> dosyasını çalıştıracak ve çıktısını konsola yazdıracaktır.</p></li></ol><h4>Start Script'inin Önemi</h4><p><strong>Start</strong> script'i, neredeyse her projede bulunabilecek temel bir script'tir. Bu script, takım üyelerinin projeye kolayca başlamasını sağlar. Çünkü çalıştırılması gereken tüm komutları bilmelerine gerek kalmaz, sadece <code>npm run start</code> komutunu kullanmaları yeterlidir. Büyük ölçekli uygulamalarda, start script'i genellikle birçok komutun kombinasyonundan oluşur. Ancak geliştirici olarak sadece <code>npm run start</code> komutunu hatırlamanız yeterlidir. Ayrıca, <strong>start</strong> özel bir script olduğu için, doğrudan <code>npm start</code> komutuyla çalıştırılabilir.</p><h4>İleri Seviye npm Scripts</h4><p>npm script'leri, sadece basit komutlardan ibaret değildir. Daha karmaşık komut dizileri oluşturabilir, diğer script'leri çağırabilir ve çeşitli npm modülleriyle entegrasyon sağlayabilirsiniz. İşte bazı ileri seviye konular:</p><ul><li><p><strong>Script'ler Arası Bağımlılık</strong>: Bir script'in diğerini çalıştırmasını sağlamak.</p></li><li><p><strong>Özel Argümanlar</strong>: Script'lere özel argümanlar eklemek.</p></li><li><p><strong>Pre ve Post Hook'lar</strong>: Bir script çalışmadan önce veya sonra belirli işlemleri gerçekleştirmek için hook'lar eklemek.</p></li><li><p><strong>Çevresel Değişkenler</strong>: Script'lerde çevresel değişkenleri kullanmak.</p></li></ul><h3>Sonuç</h3><p>npm script'ler, Node.js projelerinde sık kullanılan görevleri otomatikleştirmek ve yönetmek için güçlü araçlardır. Bu makalede, npm script'lerinin ne olduğunu, nasıl oluşturulacağını ve nasıl kullanılacağını detaylı bir şekilde ele aldık. Yeni başlayanlar için temel bilgiler sunarken, ileri seviye konulara da değindik. Node.js öğrenmeye devam ederken, npm script'lerini daha verimli kullanarak projelerinizi daha kolay yönetebilirsiniz.</p>

Node.js Projelerinde npm Scripts Kullanımı ve Yönetimi

<p>Node.js, JavaScript kodlarını sunucu tarafında çalıştırabilen açık kaynaklı bir çalıştırma ortamıdır. Bu ortamda, projelerimizi daha verimli ve modüler bir şekilde yönetmemizi sağlayan npm (Node Package Manager) kullanılır. Npm, projelerimizde kullanabileceğimiz binlerce paketi barındırır. Bu paketler iki şekilde kurulabilir: lokal (proje bazlı) ve global (sistem genelinde). Bu makalede, Node.js global paketlerinin ne olduğunu, nasıl kurulduğunu ve nasıl kullanıldığını detaylı bir şekilde inceleyeceğiz.</p><h3>1. Local ve Global Paketlerin Farkı</h3><p><strong>Local Paketler:</strong> Local paketler, belirli bir proje için kurulan ve sadece o proje kapsamında kullanılan paketlerdir. Bu paketler, projenin kök dizininde bulunan <code>node_modules</code> klasörüne indirilir. Örneğin, <code>npm install &lt;paket_adı&gt;</code> komutunu kullanarak bir paketi lokal olarak kurduğunuzda, bu paket sadece ilgili projede kullanılabilir. Local paketler, <code>package.json</code> dosyasında bağımlılık olarak listelenir ve projenin başka bir makinede çalıştırılabilmesi için bu dosya üzerinden yeniden kurulabilir.</p><p><strong>Global Paketler:</strong> Global paketler ise, sistem genelinde kurulan ve terminal üzerinden herhangi bir dizinden erişilebilen paketlerdir. Bu paketler, genellikle komut satırı uygulamalarıdır ve proje koduna doğrudan dahil edilmezler. Örneğin, <code>npm install -g &lt;paket_adı&gt;</code> komutunu kullanarak bir paketi global olarak kurduğunuzda, bu paket sistem yoluna eklenir ve terminalden erişilebilir hale gelir.</p><h3>2. Vite ve nodemon Örnekleri</h3><p><strong>Vite:</strong> Vite, modern web projeleri için hızlı ve hafif bir geliştirme ortamı sağlayan bir araçtır. Özellikle Vue.js ve React projeleri için tercih edilen Vite, anında başlatma ve sıcak modül değişimi (HMR) gibi özellikleri ile bilinir. Vite, global olarak kurulduğunda, terminalden <code>vite</code> komutunu kullanarak yeni bir proje başlatabilirsiniz. Örneğin, bir Vite projesi oluşturmak için şu komutu kullanabilirsiniz:</p><pre><code>npm create vite@latest my-vite-app</code></pre><p>Bu komut, <code>my-vite-app</code> adında yeni bir proje dizini oluşturur ve gerekli başlangıç dosyalarını indirir.</p><p><strong>nodemon:</strong> Node.js dünyasında yaygın olarak kullanılan bir diğer global paket ise <code>nodemon</code>'dur. <code>nodemon</code>, Node.js uygulamalarını geliştirirken dosya değişikliklerini izler ve otomatik olarak uygulamayı yeniden başlatır. Bu, geliştirme sürecini oldukça hızlandırır ve daha verimli hale getirir.</p><h3>3. nodemon'un Kurulumu ve Kullanımı</h3><p><code>nodemon</code> paketini global olarak kurmak oldukça basittir. Terminalde şu komutu çalıştırarak kurulum yapabilirsiniz:</p><pre><code>npm install -g nodemon</code></pre><p>Burada <code>-g</code> seçeneği, paketin global olarak kurulmasını sağlar. Bu komutun ardından, <code>nodemon</code> komutunu terminalden herhangi bir dizinde çalıştırabilirsiniz. Örneğin, projenizin ana dosyası <code>index.js</code> ise, terminalde <code>nodemon index.js</code> komutunu çalıştırarak <code>nodemon</code>'u kullanmaya başlayabilirsiniz.</p><p><code>nodemon</code>'un en büyük avantajlarından biri, kodda yapılan değişiklikleri otomatik olarak algılayıp uygulamayı yeniden başlatmasıdır. Örneğin, bir log satırını değiştirdiğinizde ve dosyayı kaydettiğinizde, <code>nodemon</code> uygulamayı otomatik olarak yeniden başlatır ve yeni değişiklikleri hemen görebilirsiniz.</p><h3>4. Global Paketlerin Özellikleri ve Önemi</h3><p>Global paketlerin en önemli özelliklerinden biri, tek bir proje için bağımlılık olarak listelenmemeleridir. Bu nedenle, <code>npm install</code> komutu çalıştırıldığında global paketler kurulmaz. Her bir geliştiricinin global paketleri kendi başına kurması gerekir. Bu durum, özellikle ekip çalışmasında önemli bir konudur çünkü her geliştiricinin aynı global paketlere sahip olması gerekebilir.</p><p>Global paketler genellikle Node.js ile yazılmış yardımcı programlar ve araçlardır. Bu araçlar, geliştirme sürecinde çeşitli görevleri otomatikleştirerek zamandan tasarruf sağlar ve projelerin daha verimli yönetilmesine yardımcı olur.</p><h3>5. Global Paketlerin Kaldırılması</h3><p>Bir global paketi kaldırmak da oldukça basittir. Terminalde şu komutu kullanarak bir global paketi kaldırabilirsiniz:</p><pre><code>npm uninstall -g &lt;paket_adı&gt;</code></pre><p>Örneğin, <code>nodemon</code> paketini kaldırmak için şu komutu çalıştırabilirsiniz:</p><pre><code>npm uninstall -g nodemon</code></pre><h3>Sonuç</h3><p>Node.js projelerinde paket yönetimi, projelerin modüler ve verimli bir şekilde geliştirilmesi için kritik bir öneme sahiptir. Local ve global paketlerin farkını anlamak, doğru paket kurulum stratejilerini belirlemek ve geliştirme sürecini optimize etmek için önemlidir. <code>nodemon</code> gibi global paketler, geliştirme sürecini hızlandıran ve kolaylaştıran güçlü araçlardır. Bu makalede, global paketlerin ne olduğunu, nasıl kurulduğunu ve nasıl kullanıldığını detaylı bir şekilde inceledik. Umarız, bu bilgiler Node.js projelerinizde size yardımcı olur.</p>

Node.js Global Paketler ve Kullanımı

<p>Yazılım geliştirme süreçlerinde versiyonlama, projelerin sürdürülebilirliği ve güncellemelerin izlenebilirliği açısından hayati bir öneme sahiptir. Bu makalede, Node.js projelerinde kullanılan versiyonlama yöntemleri ve özellikle Semantic Versioning (Anlamsal Versiyonlama) hakkında detaylı bilgiler sunacağız.</p><h3>Versiyonlama Nedir?</h3><p>Versiyonlama, bir yazılımın farklı sürümlerini takip etmek ve bu sürümler arasında yapılan değişiklikleri izlemek için kullanılan bir sistemdir. Versiyonlama sayesinde geliştiriciler, hangi sürümde ne tür değişiklikler yapıldığını ve bu değişikliklerin projenin genel işleyişini nasıl etkilediğini kolayca takip edebilir.</p><h3>npm install Komutu ve Varsayılan Davranışı</h3><p>Node.js projelerinde kullanılan <code>npm install</code> komutu, paketlerin kurulumu sırasında en sık başvurulan yöntemlerden biridir. Bu komut, bağımlılıkların (dependencies) projemize eklenmesini sağlar.</p><ul><li><p><strong>Varsayılan Kurulum:</strong> <code>npm install</code> komutu çalıştırıldığında, ilgili paketin en son kararlı sürümü kurulur. Örneğin, "moment" paketi için bu sürüm 2.29.1 olabilir.</p></li><li><p><strong>Belirli Bir Versiyonun Kurulumu:</strong> Ancak, bazen belirli bir sürümü kurmak gerekebilir. Bu durumda, <code>npm install package_name@version_number</code> komutu kullanılır. Örneğin, <code>npm install moment@2.24.0</code> komutu ile "moment" paketinin 2.24.0 sürümü kurulabilir.</p></li></ul><h3>Belirli Bir Versiyonun Kurulumu</h3><p>Bazen en son sürümde bir hata olabilir veya yeni sürümde bazı uyumsuzluklar yaşanabilir. Bu gibi durumlarda, daha stabil veya bilinen bir sürümü kullanmak mantıklıdır.</p><ul><li><p><strong>Eski Sürüme Geçiş:</strong> Yeni sürümde bir hata bulunduğunda, eski bir sürümün kurulması gerekebilir. Bu durumda, belirtilen versiyon numarası ile kurulum yapılır ve sorun çözülene kadar bu sürüm kullanılabilir.</p></li><li><p><strong>Güncelleme Yapmak:</strong> Sorun düzeltildiğinde veya yeni bir güncelleme yapıldığında, <code>npm install package_name</code> komutu ile paketin en son sürümü tekrar kurulabilir.</p></li></ul><h3>Semantic Versioning (Anlamsal Versiyonlama)</h3><p>Anlamsal Versiyonlama, yazılım dünyasında en yaygın olarak kullanılan versiyonlama sistemlerinden biridir. Bu sistem, versiyon numaralarının belirli kurallar çerçevesinde atanmasını ve artırılmasını sağlar. Versiyon numaraları, yazılımın geçirdiği değişiklikleri ve bu değişikliklerin doğasını anlamayı kolaylaştırır.</p><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1719907933/bg-forum/whvtuzorarpvvjejwqqm.png" alt="versiyonlama"><h5><strong>Semantic Versioning'in Temel Kuralları</strong></h5><p>Semantic Versioning (SemVer) sistemi, versiyon numaralarını üç ana bileşen üzerinden tanımlar: major.minor.patch.</p><ul><li><p><strong>Major (Ana) Versiyon:</strong> Geriye dönük uyumsuz değişiklikler yapıldığında artırılır. Örneğin, 1.x.x'den 2.0.0'a.</p></li><li><p><strong>Minor (Alt) Versiyon:</strong> Geriye dönük uyumlu yeni özellikler eklendiğinde artırılır. Örneğin, 1.1.x'den 1.2.0'a.</p></li><li><p><strong>Patch (Yama) Versiyon:</strong> Geriye dönük uyumlu hata düzeltmeleri yapıldığında artırılır. Örneğin, 1.1.1'den 1.1.2'ye.</p></li></ul><h3>Versiyon Numaralarının Artırılma Kuralları</h3><p><strong>Versiyon numaraları, yapılan değişikliklerin doğasına göre artırılır:</strong></p><ul><li><p><strong>Patch Artırma:</strong> Hata düzeltmeleri yapıldığında ve kod geriye dönük uyumlu kaldığında artırılır. Örneğin, 1.1.1'den 1.1.2'ye.</p></li><li><p><strong>Minor Artırma:</strong> Yeni işlevler eklendiğinde ve kod geriye dönük uyumlu kaldığında artırılır. Bu durumda, patch versiyonu sıfırlanır. Örneğin, 1.1.1'den 1.2.0'a.</p></li><li><p><strong>Major Artırma:</strong> Kod geriye dönük uyumsuz değişiklikler içerdiğinde artırılır. Bu durumda, minor ve patch versiyonları sıfırlanır. Örneğin, 1.1.1'den 2.0.0'a.</p></li></ul><h3>Ek Bilgiler</h3><p>Semantic Versioning, her zaman 0.1.0 ile başlar. Yeni bir pakette, yama numarası ile başlanmaz. Major versiyon 0, başlangıç geliştirme aşamasını temsil eder ve kod üretim için hazır hale geldiğinde, versiyon 1.0.0'a yükseltilir. En küçük değişiklik bile versiyon numarasında bir artış ile yapılmalıdır.</p><h3><strong>Versiyon Numaralarının Artırılma Kuralları - Bir Paket Örneği Üzerinden</strong></h3><p>Bu örnekte, yeni bir Node.js paketi oluşturduğumuzu ve bu paketin versiyon numaralarını nasıl artıracağımızı adım adım inceleyeceğiz. Paketimiz, basit bir matematik kütüphanesi olsun ve adını <code>simple-math</code> olarak belirleyelim.</p><p><strong>0.1.0 Başlangıcı</strong></p><h4>Paket: <code>simple-math</code></h4><ul><li><p>Bu versiyonda, sadece toplama ve çıkarma fonksiyonları mevcut ve paket hala geliştirme aşamasında.</p></li></ul><p><strong>Kod:</strong></p><pre><code>// index.js
module.exports.add = (a, b) =&gt; a + b;
module.exports.subtract = (a, b) =&gt; a - b;</code></pre><p><strong>package.json:</strong></p><pre><code>{
  "name": "simple-math",
  "version": "0.1.0",
  "description": "A simple math library",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" &amp;&amp; exit 1"
  },
  "author": "",
  "license": "ISC"
}</code></pre><h3>Patch Artırma (Hata Düzeltmeleri)</h3><p><strong>Durum:</strong></p><p>Toplama fonksiyonunda bir hata bulundu. Hata düzeltildi ve kod geriye dönük uyumlu kaldı.</p><p><strong>Kod:</strong></p><pre><code>// index.js
module.exports.add = (a, b) =&gt; {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new Error('Arguments must be numbers');
  }
  return a + b;
};
module.exports.subtract = (a, b) =&gt; a - b;</code></pre><h4>package.json:</h4><ul><li><p>Eski versiyon: 0.1.0</p></li><li><p>Yeni versiyon: 0.1.1</p></li></ul><pre><code>{
  "name": "simple-math",
  "version": "0.1.1",
  "description": "A simple math library",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" &amp;&amp; exit 1"
  },
  "author": "",
  "license": "ISC"
}</code></pre><h3>Minor Artırma (Yeni İşlevler Ekleme)</h3><p><strong>Durum:</strong></p><p>Paketimize çarpma ve bölme fonksiyonları eklendi. Bu yeni işlevler, mevcut kodu değiştirmedi ve geriye dönük uyumlu.</p><p><strong>Kod:</strong></p><pre><code>// index.js
module.exports.add = (a, b) =&gt; {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new Error('Arguments must be numbers');
  }
  return a + b;
};
module.exports.subtract = (a, b) =&gt; a - b;
module.exports.multiply = (a, b) =&gt; a * b;
module.exports.divide = (a, b) =&gt; {
  if (b === 0) {
    throw new Error('Division by zero');
  }
  return a / b;
};</code></pre><h4>package.json:</h4><ul><li><p>Eski versiyon: 0.1.1</p></li><li><p>Yeni versiyon: 0.2.0</p></li></ul><pre><code>{
  "name": "simple-math",
  "version": "0.2.0",
  "description": "A simple math library",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" &amp;&amp; exit 1"
  },
  "author": "",
  "license": "ISC"
}</code></pre><h3>Major Artırma (Üretime Hazır Hale Gelme)</h3><p><strong>Durum:</strong></p><p>Toplama ve çıkarma fonksiyonlarının isimlerini değiştirdik (add -&gt; sum, subtract -&gt; difference). Bu değişiklik, mevcut kullanıcı kodunu bozacak (geriye dönük uyumsuz). Paket artık kararlı ve üretime hazır. Fonksiyon isimleri değiştirildi ve ek özellikler eklendi.</p><p><strong>Kod:</strong></p><pre><code>// index.js
module.exports.sum = (a, b) =&gt; {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new Error('Arguments must be numbers');
  }
  return a + b;
};
module.exports.difference = (a, b) =&gt; a - b;
module.exports.multiply = (a, b) =&gt; a * b;
module.exports.divide = (a, b) =&gt; {
  if (b === 0) {
    throw new Error('Division by zero');
  }
  return a / b;
};</code></pre><h4>package.json:</h4><ul><li><p>Eski versiyon: 0.2.0</p></li><li><p>Yeni versiyon: 1.0.0</p></li></ul><pre><code>{
  "name": "simple-math",
  "version": "1.0.0",
  "description": "A simple math library",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" &amp;&amp; exit 1"
  },
  "author": "",
  "license": "ISC"
}</code></pre><p><strong>Özet</strong></p><ol><li><p><strong>Başlangıç (0.1.0):</strong> Temel toplama ve çıkarma fonksiyonları ile paket oluşturuldu.</p></li><li><p><strong>Patch Artırma (0.1.1):</strong> Hata düzeltildi ve kod geriye dönük uyumlu kaldı.</p></li><li><p><strong>Minor Artırma (0.2.0):</strong> Çarpma ve bölme fonksiyonları eklendi ve kod geriye dönük uyumlu kaldı.</p></li><li><p><strong>Major Artırma (1.0.0):</strong> Paket üretime hazır hale geldi, fonksiyon isimleri değiştirildi ve ek özellikler eklendi.</p></li></ol><p>Bu süreç, semantik versiyonlamanın kurallarını ve paketinizin gelişimine göre versiyon numaralarının nasıl değiştiğini gösterir. Versiyon numaralarının bu şekilde yönetilmesi, kullanıcıların paketinizdeki değişiklikleri ve güncellemeleri daha iyi anlamalarını sağlar.</p><h3>Sorumluluklar</h3><p>Semantic Versioning sistemi, hem geliştiricilere hem de kullanıcılara belirli sorumluluklar yükler:</p><ul><li><p><strong>Geliştiriciler:</strong> Yaptıkları değişikliklere uygun versiyon numaralarını güncellemelidir.</p></li><li><p><strong>Kullanıcılar:</strong> Güncellemeleri takip etmeli ve projelerinde gerekli düzeltmeleri yapmalıdır.</p></li></ul><h3>Sonuç</h3><p>Versiyonlama, yazılım projelerinde kritik bir rol oynar. Semantic Versioning sayesinde, yazılım paketlerinin versiyon numaraları belirli kurallar çerçevesinde atanır ve bu, yazılımın hangi değişikliklerden geçtiğini ve bu değişikliklerin etkilerini anlamayı kolaylaştırır. Geliştiricilerin ve kullanıcıların bu sisteme uygun hareket etmeleri, projelerin sürdürülebilirliği açısından büyük önem taşır.</p><p>Bu makale, versiyonlama sistemlerinin ne anlama geldiğini, nasıl doğru bir şekilde uygulanması gerektiğini ve projelere olan etkilerini anlamanıza yardımcı olmayı amaçlamaktadır.</p>

Versiyonlama: Node.js'de Sürüm Yönetimi

<p>Node.js projelerinde kullanılan <strong>package.json</strong> dosyası, projenin tüm bağımlılıklarını ve yapılandırma bilgilerini barındıran önemli bir dosyadır. Bu makalede, package.json dosyasındaki <strong>dependencies</strong> alanının ne olduğunu, neden önemli olduğunu ve nasıl kullanıldığını detaylı bir şekilde ele alacağız.</p><h3>Dependencies Alanı Nedir?</h3><p>Dependencies (bağımlılıklar) alanı, bir Node.js projesinin çalışabilmesi için gerekli olan paketleri ve bu paketlerin versiyonlarını listeler. Bu alan, npm (Node Package Manager) tarafından kullanılarak, projeye bağlı olan tüm paketlerin takibini yapar. Dependencies alanı, bir paket kurulduğunda otomatik olarak oluşturulur ve doldurulur.</p><h3>Dependencies Alanının Oluşturulması</h3><p>Bir Node.js projesinde yeni bir paket kurduğumuzda, örneğin <code>npm install moment</code> komutunu çalıştırdığımızda, npm bu paketi indirir ve package.json dosyasındaki dependencies alanına ekler. Bu, paketlerin proje için gerekliliğini ve versiyon bilgilerini kaydeder. Örneğin, aşağıdaki gibi bir package.json dosyası oluşturulabilir:</p><pre><code>{
  "name": "my-nodejs-project",
  "version": "1.0.0",
  "description": "A sample Node.js project",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "moment": "^2.29.1"
  }
}</code></pre><p>Yukarıdaki örnekte, <strong>moment</strong> paketi projenin bağımlılığı olarak belirtilmiştir.</p><h3>Dependencies Alanının Önemi</h3><p>Dependencies alanı, bir projenin çalışabilmesi için hangi paketlerin gerekli olduğunu belirtir. Bu alan, özellikle versiyon kontrol sistemleri ile çalışırken kritik bir öneme sahiptir. Proje üzerinde çalışan diğer geliştiricilerin veya ekip üyelerinin, projeyi kendi bilgisayarlarına klonladıklarında aynı bağımlılıkları kurabilmelerini sağlar.</p><h3>Gerçek Dünya Uygulamaları ve Version Control</h3><p>Gerçek dünya projelerinde, dependencies listesi bazen 5 ila 50 arasında değişen paketler içerebilir. Bu paketlerin kodları <strong>node_modules</strong> klasöründe saklanır ve bu klasör megabaytlarca veri içerebilir. Versiyon kontrol sistemlerinde (örneğin Git) node_modules klasörünün saklanması önerilmez. Bunun yerine, bu klasör <strong>.gitignore</strong> dosyasına eklenir:</p><pre><code>node_modules/</code></pre><p>Bu şekilde, node_modules klasörü versiyon kontrolüne dahil edilmez ve projenin boyutu azaltılmış olur. Ancak, bu durum projeyi klonlayan diğer geliştiricilerin bu klasörü kendi bilgisayarlarında oluşturmaları gerektiği anlamına gelir.</p><h3>Node Modules Klasörünün Eksikliği ve Hata Durumu</h3><p>Bir geliştirici projeyi klonladığında, node_modules klasörü dahil edilmeyeceğinden, projeyi çalıştırmaya çalıştığında bazı hatalarla karşılaşabilir. Örneğin, proje <code>npm install</code> komutu ile bağımlılıklar kurulmadan çalıştırılmaya çalışıldığında şu hata ile karşılaşabilir:</p><pre><code>Error: Cannot find module 'moment'</code></pre><p>Bu hata, projenin çalışabilmesi için gerekli olan paketin bulunamadığını belirtir. Geliştirici, dependencies alanındaki paketleri kurarak bu hatayı giderebilir.</p><h3>Paketlerin Yeniden Kurulması</h3><p>Dependencies alanındaki paketlerin tekrar kurulması için <code>npm install</code> komutu kullanılır. Bu komut, package.json dosyasını tarar ve gerekli paketleri otomatik olarak indirir ve kurar. Örneğin:</p><pre><code>npm install</code></pre><p>Bu komut çalıştırıldığında, npm package.json dosyasındaki dependencies alanını tarar ve belirtilen tüm paketleri indirir. Böylece, node_modules klasörü yeniden oluşturulur ve proje normal şekilde çalışmaya devam eder.</p><h3>NPM ve Paket Yöneticilerinin Rolü</h3><p>Dependencies alanı, package.json dosyasının önemli bir parçasıdır ve npm gibi paket yöneticilerinin doğru çalışması için gereklidir. Projemizdeki paketleri takip etmek, yönetmek ve gerektiğinde yeniden kurmak için kullanılır. NPM, dependencies alanındaki bilgileri kullanarak projeye bağlı paketleri yönetir ve bu paketlerin doğru versiyonlarının kurulmasını sağlar.</p><h3>Özet</h3><p>Node.js projelerinde dependencies alanı, projenin çalışabilmesi için gerekli olan paketlerin yönetilmesini sağlar. Bu alan, npm tarafından kullanılarak paketlerin takibini yapar ve gerekli durumlarda bu paketlerin yeniden kurulmasını kolaylaştırır. Versiyon kontrol sistemleri ile çalışırken node_modules klasörünün dahil edilmemesi, dependencies alanındaki paketlerin npm install komutu ile yeniden kurulmasını gerektirir. Bu şekilde, projeyi klonlayan herhangi bir geliştirici, gerekli tüm paketleri hızlıca kurabilir ve projeyi çalıştırabilir.</p><p>Dependencies alanı, Node.js projelerinde paket yönetiminin önemli bir parçasıdır ve projelerin doğru ve verimli bir şekilde çalışmasını sağlar. Bu makalede anlatılanlar, dependencies alanının nasıl çalıştığını ve neden önemli olduğunu anlamanızı kolaylaştıracaktır.</p>

Dependencies Alanının Önemi ve Kullanımı

<p>Node.js projelerinde tarih ve saat işlemlerini kolayca yönetmek için <code>moment</code> paketini kullanmak oldukça yaygındır. Bu makalede, <code>moment</code> paketinin nasıl yüklendiğini ve kullanıldığını adım adım inceleyeceğiz.</p><h3>1. Node.js ve Modüller</h3><p>Node.js'de her şey bir modül olarak organize edilmiştir. Modüller, belirli işlevleri yerine getiren ve diğer modüllerle iletişim kuran bağımsız kod parçalarıdır. Node.js'de üç tür modül bulunmaktadır:</p><ol><li><p><strong>Yerel Modüller:</strong> Kendi projemizde oluşturduğumuz ve sadece proje içinde kullanılan modüller.</p></li><li><p><strong>Yerleşik Modüller:</strong> Node.js'in kendisi tarafından sağlanan ve projelerimizde doğrudan kullanılabilen modüller.</p></li><li><p><strong>Üçüncü Parti Modüller:</strong> npm registry üzerinden yüklenebilen ve projelerimize ekleyebileceğimiz modüller.</p></li></ol><p>Yerel bir modülü ve yerleşik bir modülü import etme işlemini aşağıdaki gibi yapabiliriz:</p><ul><li><p><strong>Yerel Modül:</strong></p><pre><code>const localModule = require('./pathToModule');</code></pre></li><li><p><strong>Yerleşik Modül:</strong></p><pre><code>const fs = require('node:fs');</code></pre></li></ul><h3>2. Üçüncü Parti Modüllerin Yüklenmesi ve Kullanılması</h3><p>Üçüncü parti modüller, npm registry üzerinden yüklenir ve projelerimize eklenir. Şimdi, tarih ve saat işlemlerini kolayca yönetmek için "moment" adlı bir modülü nasıl kullanabileceğimizi görelim.</p><h5><strong>Adım 1: Modülün Yüklenmesi</strong></h5><p>Öncelikle terminal üzerinden aşağıdaki komutu kullanarak "moment" modülünü projemize ekleyelim:</p><pre><code>npm install moment</code></pre><h5><strong>Adım 2: Modülün İmport Edilmesi</strong></h5><p>Modülü projemizde kullanmak için, <code>require</code> ifadesi ile import ederiz:</p><pre><code>const moment = require('moment');</code></pre><h5><strong>Adım 3: Fonksiyonun Kullanılması</strong></h5><p>Artık modülü projemizde kullanabiliriz. Örneğin, mevcut tarihi ve saati almak ve farklı formatlarda göstermek için aşağıdaki kodu yazabiliriz:</p><ol><li><p><strong>Mevcut Tarih ve Saat:</strong></p><pre><code>const now = moment();
console.log("Current Date and Time:", now.toString());</code></pre></li><li><p><strong>Farklı Formatlarda Tarih ve Saat:</strong></p><pre><code>console.log("Formatted Date:", now.format('YYYY-MM-DD'));
console.log("Formatted Time:", now.format('HH:mm:ss'));</code></pre></li><li><p><strong>Tarih ve Saat Manipülasyonu:</strong></p><pre><code>const nextWeek = now.add(7, 'days');
console.log("Date Next Week:", nextWeek.format('YYYY-MM-DD'));</code></pre></li><li><p><strong>Tarih Farkını Hesaplama:</strong></p><pre><code>const birthDate = moment('1990-01-01');
const age = now.diff(birthDate, 'years');
console.log("Age:", age);</code></pre></li></ol><p>Bu örnekler, <code>moment</code> paketinin tarih ve saat işlemlerini nasıl kolaylaştırdığını göstermektedir.</p><h3>3. npm Paketlerinin Gücü ve Kullanım Alanları</h3><p>npm paketleri, projelerimizin işlevselliğini arttırmak için son derece faydalıdır. Basit bir örnek olarak tarih ve saat işlemlerini ele aldık. Ancak daha karmaşık ihtiyaçlar için de npm paketleri kullanabiliriz. Örneğin:</p><ul><li><p><strong>HTTP İstekleri:</strong> HTTP isteklerini yönetmek için "axios" veya "node-fetch" gibi kütüphaneleri kullanabilirsiniz.</p></li><li><p><strong>Veritabanı Bağlantıları:</strong> MongoDB, MySQL gibi veritabanlarına bağlanmak için ilgili npm paketlerini kullanabilirsiniz.</p></li><li><p><strong>Veri Doğrulama:</strong> Giriş verilerini doğrulamak için "joi" gibi kütüphaneleri kullanabilirsiniz.</p></li></ul><p>Bu paketler, projelerinizde tekrar eden işlevleri yönetmenize ve kodunuzu daha temiz ve düzenli tutmanıza yardımcı olur.</p><h3>4. package.json ve Bağımlılıklar</h3><p>Bir projeye npm paketleri eklediğimizde, bu paketler <code>package.json</code> dosyasında <code>dependencies</code> alanında listelenir. Bu alan, projenizin hangi paketlere bağımlı olduğunu belirtir ve projeyi başka bir makinede çalıştırmak istediğinizde tüm bağımlılıkları otomatik olarak yükleyebilmenizi sağlar.</p><pre><code>{
  "name": "my-node-project",
  "version": "1.0.0",
  "description": "A sample Node.js project",
  "main": "index.js",
  "dependencies": {
    "moment": "^2.29.1",
    "lodash": "^4.17.21"
  },
  "scripts": {
    "start": "node index.js"
  },
  "author": "Your Name",
  "license": "ISC"
}</code></pre><h3>Sonuç</h3><p>Node.js projelerinde npm paketlerini kullanmak, geliştirme sürecinizi hızlandırır ve daha verimli kod yazmanıza yardımcı olur. Bu rehberde, <code>moment</code> paketini nasıl yükleyip kullanacağınızı öğrendiniz. Ayrıca, paketlerin gücünü ve kullanım alanlarını da keşfettiniz. Projelerinizde npm paketlerini kullanarak, daha karmaşık ve etkili çözümler geliştirebilirsiniz.</p>

Node.js'de Paket Kullanımı: Moment Örneği

<p>Node.js projelerinde npm paketlerini kullanmak, geliştiricilerin işini oldukça kolaylaştırır. NPM (Node Package Manager), dünya çapında geliştiriciler tarafından yayımlanan milyonlarca paketi içeren bir yazılım kaydıdır. Bu rehberde, <code>moment</code> paketini indirip kurma sürecini adım adım inceleyeceğiz. <code>moment</code> paketi, tarih ve saat işlemlerini kolaylaştıran popüler bir kütüphanedir. Ancak bu rehberde, paketi kurduktan sonra nasıl kullanılacağını anlatmadan önce kurulum aşamalarını detaylandıracağız.</p><h3>Adım 1: İhtiyacımız Olan Paketi Belirleme</h3><p>İlk adım, projemizde ihtiyaç duyduğumuz paketi belirlemektir. Örneğin, tarih ve saat işlemlerini daha kolay ve esnek bir şekilde yapmamıza yardımcı olacak bir paket arıyorsak, <code>moment</code> paketi bu iş için ideal bir seçimdir. Bu paketi bulmak için <a target="_blank" rel="noopener noreferrer nofollow" href="http://npmjs.com">npmjs.com</a> adresine gidip arama kutusuna <code>moment</code> yazabiliriz.</p><h3>Adım 2: Paketi Değerlendirme</h3><p>Bir paketi kullanmadan önce, onun güvenilir ve projeye uygun olup olmadığını değerlendirmek önemlidir. Aşağıdaki kriterlere göre bir paketi değerlendirebiliriz:</p><ol><li><p><strong>Yayın Tarihi</strong>: Genellikle bir yıl içinde güncellenmiş paketler tercih edilir. Ancak, <code>moment</code> gibi temel işlevleri yerine getiren paketler için, daha eski yayın tarihlerine sahip paketler de kabul edilebilir. Örneğin, <code>moment</code> paketinin en son yayın tarihi bir yıldan eski olabilir, ancak bu paket hala geniş bir kullanıcı kitlesi tarafından kullanılmaktadır.</p></li><li><p><strong>Haftalık İndirme Sayısı</strong>: Bir paketin haftalık indirme sayısı, onun ne kadar popüler ve güvenilir olduğunu gösterir. Milyonlarca indirme varsa, paket büyük olasılıkla iyidir. <code>moment</code> paketi, haftalık milyonlarca indirmeye sahip olup, bu da onun geniş bir kullanıcı kitlesi tarafından tercih edildiğini gösterir.</p></li><li><p><strong>Paket Boyutu</strong>: Paket boyutu, projeye ek yük getirdiği için dikkat edilmelidir. Küçük boyutlu paketler tercih edilir. <code>moment</code> paketi, işlevselliğine göre makul bir boyutta olup, projeye önemli bir yük getirmez.</p></li><li><p><strong>Dokümantasyon ve Sorunlar</strong>: İyi dokümantasyona ve az sayıda açık soruna sahip paketler tercih edilir. <code>moment</code> paketi, kapsamlı dokümantasyona sahip olup, kullanıcıların sorularına ve sorunlarına hızlı yanıtlar sunar.</p></li></ol><h3>Adım 3: Paketi Yükleme</h3><p>Paketimizi değerlendirdikten sonra, yükleme işlemine geçebiliriz. <code>moment</code> paketini yüklemek için terminal veya komut istemcisinde aşağıdaki komutu çalıştırmamız yeterlidir:</p><pre><code>npm install moment</code></pre><p>Bu komut, <code>moment</code> paketini npm kaydından indirip projemize ekler. Paket <code>node_modules</code> klasörüne yüklenir ve <code>package.json</code> dosyasına bağımlılık olarak eklenir. Ayrıca <code>package-lock.json</code> dosyası oluşturulur veya güncellenir. Bu dosya, projede hangi paketlerin hangi versiyonlarının yüklendiğini izler ve tutarlılığı sağlar.</p><h3>Adım 4: Paketi Kaldırma</h3><p>Bir paketi projeden kaldırmak isterseniz, şu komutu kullanabilirsiniz:</p><pre><code>npm uninstall moment</code></pre><p>Bu komutu çalıştırdığınızda, <code>moment</code> paketi projeden kaldırılır ve <code>package.json</code>, <code>package-lock.json</code> dosyalarında ve <code>node_modules</code> klasöründe gerekli değişiklikler yapılır.</p><h3>Dosya Yapısındaki Değişiklikler</h3><p>Paket yüklendikten sonra, projemizdeki dosya yapısında bazı değişiklikler gözlemlenir:</p><ol><li><p><strong>node_modules Klasörü</strong>: Yüklenen tüm npm paketleri bu klasörde depolanır. <code>moment</code> paketi de burada yer alır.</p></li><li><p><strong>package.json Dosyası</strong>: Bu dosya, projemizin bağımlılıklarını listeler. <code>moment</code> paketini yüklediğimizde, bu dosyada bağımlılık olarak eklenir.</p></li><li><p><strong>package-lock.json Dosyası</strong>: Bu dosya, projede yüklü olan paketlerin tam sürümlerini ve bağımlılıklarını kilitler. Bu sayede, projeyi başka bir ortamda kurarken aynı bağımlılıkların aynı sürümleri kullanılabilir.</p></li></ol><h3>Sonuç</h3><p>NPM, Node.js projelerinin gelişimini hızlandıran ve kolaylaştıran güçlü bir araçtır. Bu rehberde, <code>moment</code> paketini indirip kurma sürecini adım adım anlattık. Paketlerin nasıl değerlendirileceğini ve yüklendikten sonra projede nasıl değişiklikler yapıldığını öğrendik. Bir sonraki adımda, yüklediğimiz paketin nasıl kullanılacağını öğrenerek projelerimize değer katabiliriz.</p>

Node.js'de NPM Paketlerinin Kurulumu

<p>Node.js projelerinde package.json dosyası, projenizin yapı taşlarından biridir. Bu dosya, projenizin bağımlılıklarını yönetmek, meta verileri saklamak ve npm (Node Package Manager) ile etkileşimde bulunmak için kullanılır. Bu makalede, package.json dosyasının ne olduğunu, neden önemli olduğunu ve nasıl oluşturulacağını detaylı bir şekilde ele alacağız.</p><h3>package.json Nedir?</h3><p>package.json, npm'in konfigürasyon dosyasıdır. Bu dosya, JSON (JavaScript Object Notation) formatında olup, genellikle Node.js paketinizin kök dizininde yer alır. Bu dosya, projenizle ilgili çeşitli meta verileri içerir ve aşağıdaki bilgileri sağlar:</p><ul><li><p><strong>Paket Adı</strong>: Projenizin adı.</p></li><li><p><strong>Sürüm Numarası</strong>: Projenizin versiyonu.</p></li><li><p><strong>Açıklama</strong>: Projenizin kısa açıklaması.</p></li><li><p><strong>Anahtar Kelimeler</strong>: Projenizi tanımlayan kelimeler.</p></li><li><p><strong>Ana Dosya (Main File)</strong>: Projenizin giriş noktası.</p></li></ul><h3>Neden package.json'a İhtiyacımız Var?</h3><p>package.json dosyası, bir projenin nasıl çalıştırılacağı ve onunla nasıl etkileşimde bulunulacağı konusunda merkezi bir yer sağlar. Bu dosya, npm CLI (Komut Satırı Arayüzü) tarafından kullanılır ve aşağıdaki sebeplerden dolayı önemlidir:</p><ul><li><p><strong>Bağımlılık Yönetimi</strong>: Projenizin hangi modüllere bağımlı olduğunu belirtir ve bu bağımlılıkların otomatik olarak kurulmasını sağlar.</p></li><li><p><strong>Scriptler</strong>: Proje için çeşitli komut dosyaları tanımlamanıza olanak tanır (örneğin, test, build komutları).</p></li><li><p><strong>Sürüm Yönetimi</strong>: Projenizin sürüm numarasını belirleyerek, sürüm yükseltmeleri ve güncellemelerini yönetmenizi sağlar.</p></li></ul><h3>package.json Dosyasının Oluşturulması</h3><h5><strong>Manuel Oluşturma</strong></h5><p>Bir package.json dosyasını manuel olarak oluşturmak için aşağıdaki adımları izleyebilirsiniz:</p><ol><li><p><strong>Yeni Bir Klasör Oluşturma</strong>:</p><pre><code>mkdir my-custom-package
cd my-custom-package</code></pre></li><li><p><strong>app.js Dosyası Oluşturma (CMD)</strong>:</p><pre><code>echo. &gt; app.js</code></pre></li><li><p><strong>app.js Dosyasına Basit Bir sayHello Fonksiyonu Ekleyin</strong>:</p><pre><code>function sayHello(name) {
    console.log(`Merhaba ${name}, BilGen Yazılım Akademi'ye hoş geldiniz!`);
}

module.exports = sayHello;</code></pre></li><li><p><strong>package.json Dosyasını Oluşturma</strong>:</p><pre><code>touch package.json</code></pre></li><li><p><strong>package.json Dosyasının İçeriğini Ekleyin</strong>:</p><pre><code>{
    "name": "bilgen-yazilim-akademi",
    "version": "1.0.0",
    "description": "BilGen Yazılım Akademi selamlama paketi",
    "main": "app.js",
    "keywords": ["bilgen", "yazilim", "akademi", "selamlama"]
}</code></pre></li></ol><p><strong>npm CLI Kullanarak Oluşturma</strong></p><p>package.json dosyasını manuel olarak oluşturmak yerine, npm CLI kullanarak daha hızlı ve kolay bir şekilde oluşturabilirsiniz. Bunun için aşağıdaki adımları takip edebilirsiniz:</p><ol><li><p><strong>Proje Klasörüne Geçin</strong>:</p><pre><code>cd my-custom-package</code></pre></li><li><p><strong>npm init Komutunu Çalıştırın</strong>:</p><pre><code>npm init</code></pre></li><li><p><strong>npm init -y Komutunu Kullanarak Varsayılan Değerlerle package.json Dosyasını Oluşturma</strong>:</p><pre><code>npm init -y</code></pre><p>Bu komut, tüm soruları atlayarak varsayılan değerlerle bir package.json dosyası oluşturur.</p></li></ol><h3>package.json Dosyasının İçeriği</h3><p>package.json dosyasındaki temel alanları ve bunların anlamlarını aşağıda detaylı bir şekilde inceleyelim:</p><ul><li><p><strong>name</strong>: Paketin adı. Bu alan zorunludur ve küçük harflerle, tek kelime olmalı, tire veya alt çizgi içerebilir.</p><pre><code>"name": "bilgen-yazilim-akademi"</code></pre></li><li><p><strong>version</strong>: Paketin sürümü. Bu alan da zorunludur ve semantik versiyonlama kurallarına uygun olmalıdır (örn. 1.0.0).</p><pre><code>"version": "1.0.0"</code></pre></li><li><p><strong>description</strong>: Paketin kısa açıklaması. Bu alan, npm kaydında paketinizi ararken kullanılır.</p><pre><code>"description": "BilGen Yazılım Akademi selamlama paketi"</code></pre></li><li><p><strong>keywords</strong>: Paketinizi tanımlayan anahtar kelimeler. Bu alan, paketinizi arayan kullanıcılar için faydalıdır.</p><pre><code>"keywords": ["bilgen", "yazilim", "akademi", "selamlama"]</code></pre></li><li><p><strong>main</strong>: Projenizin giriş noktası. Genellikle ana JavaScript dosyanızın adıdır.</p><pre><code>"main": "app.js"</code></pre></li></ul><h3>Sonuç</h3><p>package.json dosyası, Node.js projelerinizde kritik bir rol oynar. Bu dosya, projenizin meta verilerini saklar, bağımlılıklarını yönetir ve npm CLI ile etkileşimde bulunmanıza olanak tanır. Bu rehberde, package.json dosyasının ne olduğunu, neden önemli olduğunu ve nasıl oluşturulacağını detaylı bir şekilde ele aldık. Bundan sonraki adım, npm registry'den bir paketin nasıl yükleneceğini öğrenmektir. Bu bilgileri kullanarak, Node.js projelerinizde package.json dosyasını etkili bir şekilde kullanabilirsiniz.</p>

package.json Dosyası

<p>Node.js, özellikle arka uç geliştirme ve sunucu tarafı uygulamaları için yaygın olarak kullanılan popüler bir JavaScript çalışma ortamıdır. Node.js ekosisteminde önemli bir rol oynayan npm (Node Package Manager), geliştiricilerin projelerini daha verimli ve etkili bir şekilde yönetmelerine olanak tanır. Bu makalede, npm'in ne olduğu, nasıl çalıştığı ve yazılım geliştirme sürecindeki kritik rolü ayrıntılı olarak ele alınacaktır.</p><h3>npm Nedir?</h3><p>npm, Node.js için oluşturulmuş bir paket yöneticisidir ve iki ana işlevi vardır: <strong>yazılım kütüphanesi</strong> ve <strong>paket yöneticisi</strong> olarak çalışmak. npm, yazılım geliştirme sürecinde büyük kolaylıklar sağlar ve dünya çapında milyonlarca geliştirici tarafından kullanılır.</p><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1719731499/bg-forum/x8jayxpln1bxactlw4xe.png" alt="npm"><h3><strong>1. Yazılım Kütüphanesi Olarak npm</strong></h3><p>npm, dünyanın en büyük yazılım kütüphanesidir. Bu kütüphane, çeşitli geliştiriciler tarafından yazılmış milyonlarca kod paketini içerir. Bu kod paketleri, geliştiricilerin projelerinde tekrar kullanabilecekleri modüller ve bileşenler sunar.</p><p>Bir kitap kütüphanesi gibi, npm de çeşitli kaynakları bir araya getirir. Bir kitap kütüphanesinde nasıl çeşitli yazarların yazdığı kitaplar bulunuyorsa, npm de farklı geliştiricilerin yazdığı kod paketlerini barındırır. Bu paketler, geliştiricilerin projelerinde ihtiyaç duydukları işlevselliği hızlı ve kolay bir şekilde eklemelerine olanak tanır.</p><p>Geliştiriciler, kendi yazdıkları kod paketlerini npm kütüphanesine yükleyebilir ve diğer geliştiricilerin kullanımına sunabilir. Aynı şekilde, başkaları tarafından yazılmış kod paketlerini indirip projelerinde kullanabilirler. Bu, tekerleği yeniden icat etmek yerine, mevcut çözümleri kullanarak projelerin daha hızlı ilerlemesini sağlar.</p><h3><strong>2. Paket Yöneticisi Olarak npm</strong></h3><p>npm, sadece bir yazılım kütüphanesi değil, aynı zamanda güçlü bir paket yöneticisidir. Geliştiricilerin kod paketlerini yönetmelerine yardımcı olur ve bu süreçte karşılaşılabilecek çeşitli sorunları çözer.</p><p>Paket yönetimi, kod paketlerinin yayınlanması, güncellenmesi ve projelere eklenmesi gibi süreçleri içerir. npm, bu süreçleri basit ve sorunsuz hale getiren bir komut satırı arayüzü (CLI) sağlar. Geliştiriciler, <code>npm install</code>, <code>npm update</code> ve <code>npm publish</code> gibi komutlar kullanarak paketleri kolayca yönetebilirler.</p><p>npm ayrıca bağımlılık yönetimini de ele alır. Bir projede kullanılan bir paket başka paketlere bağımlı olabilir. npm, bu bağımlılıkları otomatik olarak indirir ve yönetir. Bu, geliştiricilerin paketlerin bağımlılıklarını manuel olarak takip etmek zorunda kalmaması anlamına gelir.</p><h3><strong>npm -v Komutu ile Versiyon Kontrolü</strong></h3><p>npm'in yüklü olup olmadığını ve hangi versiyonunun kurulu olduğunu kontrol etmek oldukça basittir. Terminal veya komut satırı arayüzünde <code>npm -v</code> komutunu çalıştırarak mevcut npm versiyonunu öğrenebilirsiniz. Bu komut, npm'in yüklü olan sürümünü gösterir ve herhangi bir ek kurulum gerektirmez. Node.js yüklendiğinde npm de otomatik olarak yüklendiği için, bu adım ayrıca bir kurulum işlemine ihtiyaç duymaz. Versiyon kontrolü, özellikle paket yönetiminde uyumluluk sorunlarını önlemek için önemlidir.</p><h3>npm Kullanmanın Önemi</h3><p>npm, Node.js geliştirme sürecinin temel bir parçasıdır ve modern yazılım geliştirme için vazgeçilmezdir. İşte npm'in önemli olduğu bazı nedenler:</p><ol><li><p><strong>Kod Yeniden Kullanımı</strong>: npm, geliştiricilerin başkaları tarafından yazılmış ve test edilmiş kodları kullanmalarına olanak tanır. Bu, projelerin daha hızlı ve daha güvenilir bir şekilde ilerlemesini sağlar.</p></li><li><p><strong>Kolay Güncellemeler</strong>: npm, projelerdeki paketlerin güncellenmesini kolaylaştırır. Geliştiriciler, <code>npm update</code> komutunu kullanarak projelerindeki tüm paketleri en son sürüme güncelleyebilirler.</p></li><li><p><strong>Bağımlılık Yönetimi</strong>: npm, bağımlılık yönetimini otomatikleştirir. Bu, geliştiricilerin projelerindeki paketlerin bağımlılıklarını manuel olarak yönetmek zorunda kalmamasını sağlar.</p></li><li><p><strong>Büyük Bir Ekosistem</strong>: npm, milyonlarca paketi barındıran büyük bir ekosistemdir. Geliştiriciler, ihtiyaçlarına uygun paketleri kolayca bulabilir ve projelerine ekleyebilirler.</p></li><li><p><strong>Topluluk Desteği</strong>: npm, büyük ve aktif bir topluluğa sahiptir. Geliştiriciler, karşılaştıkları sorunlar için topluluktan destek alabilir ve kendi deneyimlerini paylaşabilirler.</p></li></ol><h3>Sonuç</h3><p>npm, Node.js geliştirme sürecinde önemli bir rol oynar ve modern yazılım geliştirme için vazgeçilmez bir araçtır. Yazılım kütüphanesi ve paket yöneticisi olarak işlev gören npm, geliştiricilerin projelerini daha verimli ve etkili bir şekilde yönetmelerine olanak tanır. Kod yeniden kullanımı, kolay güncellemeler, bağımlılık yönetimi ve büyük bir ekosistem gibi özellikleriyle npm, yazılım geliştirme sürecini önemli ölçüde iyileştirir. Node.js öğrenirken npm'in nasıl çalıştığını ve neden önemli olduğunu anlamak, geliştiricilerin başarılı projeler oluşturmasına yardımcı olacaktır. Versiyon kontrolü için <code>npm -v</code> komutunun kullanımı, npm'in kurulu olup olmadığını ve hangi sürümde olduğunu hızlı bir şekilde kontrol etmeyi sağlar, bu da geliştiricilerin uyumluluk ve güncellemeler konusunda bilgi sahibi olmasına yardımcı olur.</p>

Node.js ve npm: Yazılım Kütüphanesi ve Paket Yöneticisi

<p>Node.js, asenkron işlemleri verimli bir şekilde yönetmek için event-driven (olay güdümlü) bir mimari kullanır. Bu mimarinin temel taşlarından biri olan <strong>Event Loop</strong>, Node.js'nin senkron ve asenkron kodları koordine etmesini sağlar. Bu makalede, Event Loop'un son adımı olan <strong>Close Queue</strong> ve onun çalışma prensipleri detaylı bir şekilde ele alınacaktır.</p><h4>Event Loop Nedir?</h4><p>Event Loop, Node.js'nin kalbidir ve JavaScript motorunun senkron ve asenkron işlemleri yönetmesini sağlar. Event Loop, altı ana kuyruktan (queue) oluşur:</p><ol><li><p><strong>Next Tick Queue</strong>: <code>process.nextTick</code> ile kuyruklanan callback'ler burada yer alır.</p></li><li><p><strong>Promise Queue</strong>: Promise'lerin resolve veya reject edilmesiyle kuyruklanan callback'ler burada yer alır.</p></li><li><p><strong>Timer Queue</strong>: <code>setTimeout</code> ve <code>setInterval</code> ile kuyruklanan callback'ler burada yer alır.</p></li><li><p><strong>IO Queue</strong>: Asenkron IO operasyonları tamamlandığında kuyruklanan callback'ler burada yer alır.</p></li><li><p><strong>Check Queue</strong>: <code>setImmediate</code> ile kuyruklanan callback'ler burada yer alır.</p></li><li><p><strong>Close Queue</strong>: Close event'leri ile kuyruklanan callback'ler burada yer alır.</p></li></ol><h4>Close Queue</h4><p>Close Queue, bir kaynak (örneğin bir dosya veya ağ bağlantısı) kapandığında tetiklenen callback fonksiyonlarının kuyruklandığı yerdir. Close Queue'nun en önemli özelliklerinden biri, diğer tüm kuyruklar boşaldıktan sonra çalıştırılmasıdır. Bu, kaynakların temizlenmesi ve kapanma işlemlerinin diğer tüm işlemler tamamlandıktan sonra yapılmasını sağlar.</p><h4>Close Queue'nun Kullanımı</h4><p>Bir örnekle Close Queue'nun nasıl çalıştığını inceleyelim. Aşağıdaki kod, bir readable stream oluşturur, bu stream'i kapatır ve <code>close</code> event'ini dinler.</p><pre><code>const fs = require("fs");

// Readable stream oluşturuluyor
const readableStream = fs.createReadStream(__filename);

// Stream kapatılıyor
readableStream.close();

// Close event dinleniyor
readableStream.on("close", () =&gt; {
  console.log("readableStream close event callback");
});

// Diğer asenkron metotlar
setImmediate(() =&gt; console.log("setImmediate 1"));
setTimeout(() =&gt; console.log("setTimeout 1"), 0);
Promise.resolve().then(() =&gt; console.log("Promise.resolve 1"));
process.nextTick(() =&gt; console.log("process.nextTick 1"));</code></pre><p>Bu kod çalıştırıldığında, aşağıdaki çıktı elde edilir:</p><ol><li><p><code>process.nextTick callback</code></p></li><li><p><code>Promise.resolve callback</code></p></li><li><p><code>setTimeout callback</code></p></li><li><p><code>setImmediate callback</code></p></li><li><p><code>readable stream close event callback</code></p></li></ol><p>Bu çıktıya göre, Close Queue'daki callback'ler diğer tüm kuyruklar boşaldıktan sonra çalıştırılır.</p><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1718975751/bg-forum/s3dca6rmmvmql1chmdpm.gif" alt="close queue gif"><h4>Event Loop ve Kuyrukların Yürütülme Sırası</h4><p>Event Loop, her döngüsünde aşağıdaki adımları izler:</p><ol><li><p><strong>Call Stack'in Boşaltılması</strong>: İlk olarak, call stack'teki tüm senkron kodlar çalıştırılır.</p></li><li><p><strong>Next Tick Queue</strong>: <code>process.nextTick</code> ile kuyruklanan callback'ler çalıştırılır.</p></li><li><p><strong>Promise Queue</strong>: Promise'lerin resolve veya reject edilmesiyle kuyruklanan callback'ler çalıştırılır.</p></li><li><p><strong>Timer Queue</strong>: <code>setTimeout</code> ve <code>setInterval</code> ile kuyruklanan callback'ler çalıştırılır.</p></li><li><p><strong>IO Queue</strong>: Asenkron IO operasyonları tamamlandığında kuyruklanan callback'ler çalıştırılır.</p></li><li><p><strong>Check Queue</strong>: <code>setImmediate</code> ile kuyruklanan callback'ler çalıştırılır.</p></li><li><p><strong>Close Queue</strong>: Close event'leri ile kuyruklanan callback'ler çalıştırılır.</p></li></ol><h4>Event Loop'un Çalışma Mantığı</h4><p>Event Loop, Node.js'nin senkron ve asenkron işlemleri koordine etmesini sağlar. Her bir kuyruk, belirli türdeki asenkron işlemler için kullanılır ve bu kuyruklar belirli bir sırayla işlenir. Örneğin, <code>process.nextTick</code> ve Promise callback'leri her bir kuyruk ve callback yürütme arasında çalıştırılır, bu da onların diğer asenkron işlemlerden önce çalıştırılmasını sağlar.</p><h4>Sonuç</h4><p>Node.js Event Loop, senkron ve asenkron kodların verimli bir şekilde çalıştırılmasını sağlayan karmaşık fakat güçlü bir yapıdır. Close Queue, kaynakların kapanma işlemlerinin diğer tüm işlemler tamamlandıktan sonra yapılmasını sağlayarak, kaynak yönetimini daha verimli hale getirir. Bu makalede, Event Loop'un çalışma prensipleri ve Close Queue'nun nasıl çalıştığı detaylı bir şekilde ele alınmıştır. Node.js geliştiricileri için bu bilgilerin anlaşılması, asenkron kodların daha verimli ve etkili bir şekilde yazılmasına yardımcı olacaktır.</p>

Node.js'de Close Queue

<p>C# programlama dilinde dosya işlemleri, dosyalardan veri okuma veya dosyalara veri yazma işlemlerini kapsar. Bu işlemler, <code>System.IO</code> ad alanı altındaki sınıflar aracılığıyla gerçekleştirilir.</p><h2>Dosyaya Yazma</h2><p>Dosyaya yazmak için <code>StreamWriter</code> sınıfı kullanılır. Bu sınıf, belirtilen dosyaya metin yazmanıza olanak tanır. Eğer dosya mevcut değilse, belirtilen yolda yeni bir dosya oluşturulur.</p><pre><code class="language-csharp">using System.IO;

string dosyaYolu = @"C:\\\\ornek.txt";
using (StreamWriter writer = new StreamWriter(dosyaYolu))
{
    writer.WriteLine("Merhaba Dünya!");
}
</code></pre><p>Bu kod parçası, belirtilen yolda "Merhaba Dünya!" metnini içeren bir dosya oluşturur.</p><h2>Dosyadan Okuma</h2><p>Dosyadan okumak için <code>StreamReader</code> sınıfı kullanılır. Bu sınıf, belirtilen dosyadan metin okumanıza olanak tanır.</p><pre><code class="language-csharp">using System.IO;

string dosyaYolu = @"C:\\\\ornek.txt";
using (StreamReader reader = new StreamReader(dosyaYolu))
{
    string icerik = reader.ReadToEnd();
    Console.WriteLine(icerik);
}
</code></pre><p>Bu kod parçası, belirtilen dosyanın tüm içeriğini okur ve konsola yazdırır.</p><h2>Dosyaya Ekleme</h2><p>Var olan bir dosyaya veri eklemek için <code>StreamWriter</code> sınıfının bir overload'ını kullanarak <code>append</code> modunu <code>true</code> olarak belirleyebilirsiniz. Bu şekilde, dosyanın mevcut içeriğinin üzerine yazmak yerine, dosyanın sonuna yeni veriler eklenir.</p><pre><code class="language-csharp">using System.IO;

string dosyaYolu = @"C:\\\\ornek.txt";
using (StreamWriter writer = new StreamWriter(dosyaYolu, true))
{
    writer.WriteLine("Yeni satır");
}
</code></pre><p>Bu kod parçası, mevcut dosyanın sonuna "Yeni satır" metnini ekler.</p><h2>Try-Catch Bloğu ile Hata Yönetimi</h2><p>Dosya işlemleri sırasında oluşabilecek hataları yönetmek için <code>try-catch</code> blokları kullanılabilir. Örneğin, dosya bulunamadığında <code>FileNotFoundException</code> hatası yönetilebilir:</p><pre><code class="language-csharp">using System;
using System.IO;

string dosyaYolu = @"C:\\\\olmayanDosya.txt";
try
{
    using (StreamReader reader = new StreamReader(dosyaYolu))
    {
        string icerik = reader.ReadToEnd();
        Console.WriteLine(icerik);
    }
}
catch (FileNotFoundException)
{
    Console.WriteLine("Dosya bulunamadı.");
}
</code></pre><p>Bu kod parçası, belirtilen dosya mevcut değilse, bir hata mesajı yazdırır.</p><h2>Sonuç</h2><p>C# ile dosya işlemleri, <code>System.IO</code> ad alanındaki sınıflar sayesinde kolayca gerçekleştirilebilir. <code>StreamWriter</code> ve <code>StreamReader</code> sınıfları, dosyalara yazma ve dosyalardan okuma işlemleri için temel araçlardır. Dosya işlemleri sırasında hata yönetimi için <code>try-catch</code> bloklarının kullanılması önemlidir. Bu sayede, programın beklenmedik hatalar karşısında daha sağlam olması sağlanır.</p>

C# ile Dosya İşlemleri (File IO)

<p>C# programlama dilinde, struct (yapı), ilkel veri türlerini veya farklı veri türlerini bir araya getirerek yeni bir veri türü oluşturmanızı sağlayan bir yapıdır. Class'lara benzerler, ancak bazı önemli farklılıklara sahiptirler. Struct'lar genellikle küçük veri gruplarını saklamak için kullanılır ve değer türüdürler, yani doğrudan değerleri saklarlar.</p><h2>Struct Tanımlama</h2><p>Bir struct tanımlamak için <code>struct</code> anahtar kelimesi kullanılır. Örneğin, bir banka hesabını temsil eden bir struct aşağıdaki gibi olabilir:</p><pre><code class="language-csharp">struct Hesap
{
    public int Id;
    public double Bakiye;
    public string Sahibi;
    public string Sehir;
}
</code></pre><p>Bu örnekte, bir <code>Hesap</code> struct'ı tanımlanmış ve dört adet public alan (field) içermektedir: <code>Id</code>, <code>Bakiye</code>, <code>Sahibi</code> ve <code>Sehir</code>.</p><h2>Struct Kullanımı</h2><p>Bir struct'ı kullanmak için, önce bir örneğini (instance) oluşturmanız gerekir:</p><pre><code class="language-csharp">Hesap hesabim = new Hesap();
hesabim.Id = 1;
hesabim.Bakiye = 10000.50;
hesabim.Sahibi = "Ali Veli";
hesabim.Sehir = "İstanbul";
</code></pre><p>Bu örnekte, <code>Hesap</code> türünde <code>hesabim</code> adında bir değişken oluşturulmuş ve alanlarına değerler atanmıştır.</p><h2>Struct Metodları</h2><p>Struct'lar içerisinde metodlar tanımlayabilir ve bu metodları struct'ın bir örneği üzerinden çağırabilirsiniz:</p><pre><code class="language-csharp">struct Hesap
{
    public int Id;
    public double Bakiye;
    // Diğer alanlar...

    public void ParaEkle(double miktar)
    {
        Bakiye += miktar;
    }

    public void ParaCek(double miktar)
    {
        Bakiye -= miktar;
    }
}

// Kullanımı:
hesabim.ParaEkle(500);
hesabim.ParaCek(200);
</code></pre><h2>Struct Constructor (Yapıcı) Metodlar</h2><p>Struct'lar için parametreli constructor'lar tanımlayabilirsiniz. Ancak, struct'larda parametresiz constructor tanımlanamaz çünkü varsayılan olarak zaten bir parametresiz constructor vardır ve bu, struct'ın alanlarını varsayılan değerlerle başlatır:</p><pre><code class="language-csharp">struct Hesap
{
    public int Id;
    public double Bakiye;
    public string Sahibi;
    public string Sehir;

    public Hesap(int id, double bakiye, string sahibi, string sehir)
    {
        Id = id;
        Bakiye = bakiye;
        Sahibi = sahibi;
        Sehir = sehir;
    }
}

// Kullanımı:
Hesap hesabim = new Hesap(1, 10000.50, "Ali Veli", "İstanbul");
</code></pre><h2>Struct vs Class</h2><p>Ana farklar:</p><ul><li><p>Struct'lar değer türüdür ve stack üzerinde saklanır, class'lar ise referans türüdür ve heap üzerinde saklanır.</p></li><li><p>Struct'lar, küçük ve basit veri yapılarını temsil etmek için daha uygun olabilirken, class'lar daha karmaşık veri yapıları ve davranışlar için tercih edilir.</p></li></ul><h2>Sonuç</h2><p>Struct'lar, C# programlamada veri saklama ve basit işlemler gerçekleştirme amacıyla kullanılan kullanışlı yapısal birimlerdir. Değer türü olmaları ve stack üzerinde saklanmaları nedeniyle, bazı durumlarda class'lara göre performans avantajları sunabilirler. Ancak, kullanım durumunuza bağlı olarak struct veya class kullanımı arasında doğru seçimi yapmak önemlidir.</p>

C# ile Structs (Yapılar)

<p>C# programlama dilinde, lambda ifadeleri kısa ve öz fonksiyonlar tanımlamanıza olanak tanır. Temelde, bir lambda ifadesi, isimsiz bir metottur ve genellikle kısa süreli işlemler için kullanılır. Lambda ifadeleri, özellikle koleksiyonlar üzerinde işlemler yaparken LINQ sorguları ile birlikte sıklıkla kullanılır.</p><h2>Lambda İfadelerinin Yapısı</h2><p>Lambda ifadeleri <code>=&gt;</code> operatörü kullanılarak tanımlanır. Sol tarafta, fonksiyonun alacağı parametreler, sağ tarafta ise bu parametrelerle yapılacak işlem yer alır:</p><pre><code class="language-csharp">(parametreler) =&gt; ifade
</code></pre><p>Örnek olarak, iki sayının çarpımını döndüren bir lambda ifadesi aşağıdaki gibi olabilir:</p><pre><code class="language-csharp">Func&lt;int, int, int&gt; carpim = (a, b) =&gt; a * b;
</code></pre><p>Bu örnekte, <code>Func&lt;int, int, int&gt;</code> tanımı, iki adet <code>int</code> türünde parametre alıp, bir <code>int</code> türünde değer döndüren bir fonksiyonu ifade eder. <code>(a, b)</code> lambda ifadesinin parametrelerini belirtirken, <code>a * b</code> ise bu parametrelerle yapılacak işlemi tanımlar.</p><h2>Lambda İfadelerinin Kullanımı</h2><p>Lambda ifadeleri, koleksiyonlar üzerinde işlemler gerçekleştirmek için sıkça kullanılır. Örneğin, bir sayı listesinden çift sayıları filtrelemek için şu şekilde bir lambda ifadesi kullanabilirsiniz:</p><pre><code class="language-csharp">List&lt;int&gt; sayilar = new List&lt;int&gt;() {1, 2, 3, 4, 5};
List&lt;int&gt; ciftSayilar = sayilar.Where(n =&gt; n % 2 == 0).ToList();
</code></pre><p>Burada, <code>.Where(n =&gt; n % 2 == 0)</code> lambda ifadesi, <code>sayilar</code> listesindeki her bir <code>n</code> elemanı için <code>n % 2 == 0</code> koşulunu kontrol eder ve bu koşulu sağlayan elemanları yeni bir liste olarak döndürür.</p><h2>Lambda İfadeleri ve Metod Çağrıları</h2><p>Lambda ifadeleri, metod çağrılarında da kullanılabilir. Örneğin, bir listenin her bir elemanı için bir işlem yapmak istediğinizde, <code>ForEach</code> metodunu kullanarak lambda ifadesi geçirebilirsiniz:</p><pre><code class="language-csharp">sayilar.ForEach(n =&gt; Console.WriteLine(n * 2));
</code></pre><p>Bu kod, <code>sayilar</code> listesindeki her bir <code>n</code> elemanı için <code>Console.WriteLine(n * 2)</code> ifadesini çalıştırır ve böylece listendeki her sayının iki katını ekrana yazdırır.</p><h2>Sonuç</h2><p>Lambda ifadeleri, C# programlamada kodunuzu daha sade ve okunabilir hale getirmenizi sağlar. Özellikle koleksiyonlar ve LINQ sorguları ile çalışırken, karmaşık işlemleri tek bir satırda ifade etmenize olanak tanır. Lambda ifadelerinin kullanımı, kod tekrarını azaltır ve programın genel anlaşılırlığını artırır.</p>

C# ile Lambda İfadeleri (Expressions)

<p>C# programlama dilinde metodlar veya fonksiyonlar, belirli bir işlevi gerçekleştiren kod bloklarıdır. Metodlar, kodun tekrar kullanılabilirliğini ve organizasyonunu artırır. Bir metod, girdi olarak parametre alabilir ve bir çıktı döndürebilir.</p><h2>Metod Tanımlama</h2><p>Bir metod tanımlarken, metodun dönüş türü, adı ve parametre listesi belirtilir. Eğer metod bir değer döndürmeyecekse, dönüş türü olarak <code>void</code> kullanılır:</p><pre><code class="language-csharp">public int Topla(int a, int b) {
    return a + b;
}
</code></pre><p>Bu örnekte, <code>Topla</code> isimli bir metod tanımlanmıştır ve iki <code>int</code> türünde parametre alıp, bu parametrelerin toplamını döndürür.</p><h2>Metod Çağırma</h2><p>Bir metod, adı ve gerektiği kadar parametre ile birlikte çağrılır:</p><pre><code class="language-csharp">int sonuc = Topla(3, 5);
Console.WriteLine(sonuc); // Çıktı: 8
</code></pre><h2>Metod İmzası ve Aşırı Yükleme (Overloading)</h2><p>Bir metodun imzası, metodun adı ve parametre listesinin türlerinden oluşur. C# dilinde, aynı ada sahip ancak farklı parametre listelerine sahip birden fazla metod tanımlayabilirsiniz. Bu, metod aşırı yüklemesi olarak bilinir:</p><pre><code class="language-csharp">public int Topla(int a, int b) {
    return a + b;
}

public int Topla(int a, int b, int c) {
    return a + b + c;
}
</code></pre><p>Bu örnekte, <code>Topla</code> metodunun iki farklı versiyonu vardır: biri iki parametre alırken, diğeri üç parametre alır.</p><h2>Metod İçinde Metod</h2><p>Bir metod içerisinde başka bir metod çağrılabilir. Bu, kodun tekrar kullanımını ve okunabilirliğini artırabilir:</p><pre><code class="language-csharp">public int CarpVeTopla(int a, int b, int c) {
    int carpim = Carp(a, b);
    return carpim + c;
}

public int Carp(int x, int y) {
    return x * y;
}
</code></pre><h2>Parametre Türleri</h2><p>C# programlamada, metod parametreleri için farklı türler kullanabilirsiniz:</p><ul><li><p>Değer türleri (<code>int</code>, <code>double</code> vb.)</p></li><li><p>Referans türleri (<code>string</code>, <code>array</code>, <code>object</code> vb.)</p></li><li><p><code>out</code> ve <code>ref</code> anahtar kelimeleri ile parametreler</p></li></ul><h2><code>void</code> Metodlar</h2><p>Bir metod eğer herhangi bir değer döndürmeyecekse, dönüş türü <code>void</code> olarak belirlenir:</p><pre><code class="language-csharp">public void Yazdir(string mesaj) {
    Console.WriteLine(mesaj);
}
</code></pre><h2>Sonuç</h2><p>C# dilinde metodlar, kod tekrarını önleyen, kodun okunabilirliğini ve yönetilebilirliğini artıran güçlü araçlardır. Aşırı yüklenmiş metodlar, aynı işlemi farklı parametrelerle yapabilmek için kullanılabilir. Metodlar, programlama pratiğinde sıklıkla kullanılan önemli bir özelliktir.</p>

C# ile Metodlar (Fonksiyonlar)

<p>C# programlama dilinde enumlar ya da Türkçe adıyla sabit listeler, belirli bir değişkenin alabileceği sabit değerler kümesini tanımlamak için kullanılır. Enumlar, kodun okunabilirliğini ve güvenliğini artırırken, hatalı değer atamalarını önlemeye yardımcı olur.</p><h2>Enum Tanımlama</h2><p>Enum, belirli bir değişken türü için önceden belirlenmiş sabit değerler kümesini ifade eder. Örneğin, bir araba modelini temsil eden bir enum tanımlayabilirsiniz:</p><pre><code class="language-csharp">enum ArabaModeli {
    BMW,
    Mercedes,
    Ferrari,
    Rover
}
</code></pre><p>Bu örnekte, <code>ArabaModeli</code> adında bir enum tanımlanmış ve bu enumun alabileceği değerler (<code>BMW</code>, <code>Mercedes</code>, <code>Ferrari</code>, <code>Rover</code>) belirtilmiştir.</p><h2>Enum Kullanımı</h2><p>Tanımlanan enum türünde bir değişken oluşturup, bu değişkene enum içinde tanımlanmış değerlerden birini atayabilirsiniz:</p><pre><code class="language-csharp">ArabaModeli benimArabam = ArabaModeli.BMW;
</code></pre><p>Bu örnekte, <code>benimArabam</code> adında <code>ArabaModeli</code> türünde bir değişken tanımlanmış ve bu değişkene <code>BMW</code> değeri atanmıştır.</p><h2>Enum ile Karşılaştırma ve Kontrol</h2><p>Enum değerleri üzerinde karşılaştırma yaparak koşullu ifadeler oluşturabilirsiniz:</p><pre><code class="language-csharp">if (benimArabam == ArabaModeli.BMW) {
    Console.WriteLine("Arabam BMW modelidir.");
}
</code></pre><p>Bu örnekte, eğer <code>benimArabam</code> değişkeninin değeri <code>BMW</code> ise konsola bir mesaj yazdırılır.</p><h2>Enum ve Switch Case</h2><p>Enumlar, <code>switch</code> case yapısıyla birlikte kullanıldığında çok daha güçlü ve okunabilir kodlar oluşturmanıza olanak tanır:</p><pre><code class="language-csharp">switch (benimArabam) {
    case ArabaModeli.BMW:
        Console.WriteLine("Arabam BMW modelidir.");
        break;
    case ArabaModeli.Mercedes:
        Console.WriteLine("Arabam Mercedes modelidir.");
        break;
    // Diğer durumlar...
}
</code></pre><p>Bu yapı, <code>benimArabam</code> değişkeninin alabileceği her bir enum değeri için farklı işlemler yapılmasını sağlar.</p><h2>Enum ve İntegral Değerler</h2><p>Enumlar arkada birer sayısal değere (genellikle <code>int</code>) karşılık gelir. Varsayılan olarak, ilk enum değeri <code>0</code>'dır ve sonraki her enum değeri bir öncekinin bir fazlasıdır. Ancak, bu değerler özel olarak atanabilir:</p><pre><code class="language-csharp">enum Gunler {
    Pazartesi = 1,
    Sali = 2,
    Carsamba = 3,
    // Diğer günler...
}
</code></pre><p>Enum değerlerinin sayısal karşılıklarını kullanarak da işlemler yapabilirsiniz.</p><h2>Sonuç</h2><p>C# dilinde enumlar, belirli bir değişkenin alabileceği değerleri sınırlandırmak ve kodun anlaşılabilirliğini artırmak için kullanılır. Enumlar sayesinde, hatalı değer atamalarının önüne geçilir ve kodun daha güvenli, okunabilir olmasına katkıda bulunulur.</p>

C# ile Enum (Sabit Listeler) Kullanımı

<p>C# programlama dilinde istisna yönetimi, programın beklenmedik hatalarla veya istisnalarla karşılaştığında nasıl davranacağını belirlemenizi sağlar. Bir programın çalışma zamanında karşılaşabileceği her türlü hata veya beklenmedik durum için bir "yedek plan" oluşturmak gibidir. Bu sayede, programınız hatalar karşısında çökmez ve kullanıcıya anlaşılır hata mesajları gösterebilir.</p><h2>Temel İstisna Yönetimi: Try-Catch Bloğu</h2><p>İstisna yönetiminin temeli, <code>try</code> ve <code>catch</code> anahtar kelimeleri ile oluşturulan bloklardır. <code>try</code> bloğu içinde, hata oluşturabilecek kodlar yazılır. Eğer <code>try</code> bloğu içinde bir hata meydana gelirse, program kontrolü hemen <code>catch</code> bloğuna geçer.</p><pre><code class="language-csharp">try {
    // Hata oluşturabilecek kodlar
    int sayi = 10;
    int sonuc = sayi / 0; // Sıfıra bölme hatası oluşturur.
}
catch (Exception ex) {
    // Hata meydana geldiğinde çalışacak kodlar
    Console.WriteLine("Bir hata oluştu: " + ex.Message);
}
</code></pre><p>Bu örnekte, sıfıra bölme işlemi bir <code>DivideByZeroException</code> hatası oluşturur. Bu hata, <code>catch</code> bloğu tarafından yakalanır ve kullanıcıya hata mesajı olarak gösterilir.</p><h2>Hata Türlerine Göre Catch Blokları</h2><p>Farklı hata türleri için farklı <code>catch</code> blokları tanımlayabilirsiniz. Bu sayede, programınız farklı hatalara farklı tepkiler verebilir:</p><pre><code class="language-csharp">try {
    // Hata oluşturabilecek kodlar
}
catch (DivideByZeroException ex) {
    // Sıfıra bölme hatasıyla ilgili özel işlemler
    Console.WriteLine("Sıfıra bölme hatası: " + ex.Message);
}
catch (IndexOutOfRangeException ex) {
    // Dizi indeksi hatasıyla ilgili özel işlemler
    Console.WriteLine("İndeks dışı hatası: " + ex.Message);
}
catch (Exception ex) {
    // Diğer tüm hatalar için genel bir işlem
    Console.WriteLine("Genel hata: " + ex.Message);
}
</code></pre><h2>Finally Bloğu</h2><p><code>finally</code> bloğu, hata olsun ya da olmasın, <code>try</code> veya <code>catch</code> bloklarından sonra her zaman çalıştırılmak üzere tasarlanmış bir bloktur. Genellikle kaynakların temizlenmesi ve açık dosya bağlantılarının kapatılması gibi işlemler için kullanılır:</p><pre><code class="language-csharp">try {
    // Hata oluşturabilecek kodlar
}
catch (Exception ex) {
    // Hata meydana geldiğinde çalışacak kodlar
    Console.WriteLine("Hata: " + ex.Message);
}
finally {
    // Hata olsun ya da olmasın çalışacak kodlar
    Console.WriteLine("Finally bloğu çalıştı.");
}
</code></pre><h2>Sonuç</h2><p>C# programlamada istisna yönetimi, hataların ve beklenmedik durumların programınızı çökertmesini önlemek için hayati öneme sahiptir. <code>try-catch</code> ve <code>finally</code> blokları, programınızın daha kararlı ve güvenilir çalışmasını sağlamak için kullanılır. Bu yapılar sayesinde, hatalar programın akışını kesmeden uygun bir şekilde yönetilebilir ve kullanıcılara daha iyi bir deneyim sunulabilir.</p>

C# ile İstisna (Exception) Yönetimi - (Try...Catch)

<p>C# programlama dilinde, listeler dizilere benzer şekilde veri koleksiyonlarını tutar, ancak boyutları dinamik olarak değişebilir. Yani bir liste, eleman eklendiğinde büyüyebilir veya eleman çıkarıldığında küçülebilir. Bu esneklik, listeleri pek çok durumda dizilere tercih edilen bir yapı haline getirir.</p><h2>Listelerin Tanımlanması</h2><p>Bir liste tanımlamak için öncelikle <code>System.Collections.Generic</code> ad alanını kullanmanız gerekir. Ardından, liste içerisinde tutmak istediğiniz veri türünü belirtirsiniz:</p><pre><code class="language-csharp">using System.Collections.Generic;

List&lt;int&gt; sayilar = new List&lt;int&gt;();
</code></pre><p>Bu örnekte, <code>int</code> türünde bir <code>sayilar</code> listesi oluşturduk.</p><h2>Listeye Eleman Ekleme</h2><p>Listeye eleman eklemek için <code>.Add()</code> metodu kullanılır:</p><pre><code class="language-csharp">sayilar.Add(6);
sayilar.Add(12);
sayilar.Add(20);
</code></pre><h2>Eleman Sayısını ve Elemanları Yazdırma</h2><p>Listedeki eleman sayısını <code>.Count</code> özelliği ile elde edebilir ve listeyi yazdırmak için bir döngü kullanabilirsiniz:</p><pre><code class="language-csharp">Console.WriteLine(sayilar.Count); // Eleman sayısını yazdırır.

foreach (var eleman in sayilar) {
    Console.WriteLine(eleman); // Listede bulunan her elemanı yazdırır.
}
</code></pre><h2>Liste İşlemleri</h2><h3>Listeden Eleman Çıkarma</h3><p>Listeden bir elemanı çıkarmak için <code>.Remove()</code> metodu kullanılır. Bu metod, belirtilen değeri listeden çıkarır:</p><pre><code class="language-csharp">sayilar.Remove(12); // 12 değerini listeden çıkarır.
</code></pre><h3>Belirli Bir İndeksteki Elemanı Çıkarma</h3><p>Belirli bir indeksteki elemanı çıkarmak için <code>.RemoveAt()</code> metodu kullanılır:</p><pre><code class="language-csharp">sayilar.RemoveAt(1); // İkinci elemanı (indeksi 1 olan) listeden çıkarır.
</code></pre><h3>Listeye Birden Fazla Eleman Ekleme</h3><p>Birden fazla elemanı bir seferde listeye eklemek için <code>.AddRange()</code> metodu kullanılır. Bu metod, başka bir koleksiyonu veya diziyi parametre olarak alır:</p><pre><code class="language-csharp">int[] eklenenSayilar = {100, 200, 300};
sayilar.AddRange(eklenenSayilar);
</code></pre><h2>Liste Elemanlarını Temizleme</h2><p>Listedeki tüm elemanları temizlemek için <code>.Clear()</code> metodu kullanılır:</p><pre><code class="language-csharp">sayilar.Clear(); // Listedeki tüm elemanları temizler.
</code></pre><h2>Liste Elemanlarını Sıralama</h2><p>Listedeki elemanları sıralamak için <code>.Sort()</code> metodu kullanılır:</p><pre><code class="language-csharp">sayilar.Sort(); // Listeyi sıralar.
</code></pre><h2>Sonuç</h2><p>C# dilinde listeler, dizilere göre daha dinamik ve esnek yapılar sunar. Eleman ekleme, çıkarma, sıralama gibi işlemleri kolaylıkla gerçekleştirebilir, listelerin boyutunu ihtiyaca göre değiştirebilirsiniz. Bu özellikler, listeleri dinamik veri koleksiyonları ile çalışırken vazgeçilmez kılar. Özellikle, programın çalışma zamanında eleman sayısının değişebileceği durumlar için listeler ideal bir seçimdir.</p>

C# ile Listeler (Lists)

<p>C# programlama dilinde, dizi ya da array, aynı türden verilerin sıralı bir koleksiyonunu temsil eder. Diziler, birden çok öğeyi tek bir değişken altında depolamak için kullanılır. Örneğin, bir sınıftaki öğrencilerin notlarını bir dizi içinde tutabilirsiniz.</p><h2>Dizi Tanımlama</h2><p>Bir dizi tanımlamak için, öğe türünün ardından köşeli parantez <code>[]</code> kullanılır. Daha sonra diziye bir isim verilir:</p><pre><code class="language-csharp">int[] myArray;
</code></pre><p>Bu örnekte, <code>int</code> türünde bir <code>myArray</code> adında bir dizi tanımlanmıştır. Ancak bu dizi henüz herhangi bir boyuta veya değere sahip değildir.</p><h2>Diziye Değer Atama</h2><p>Bir diziye değer atamak için, <code>new</code> anahtar kelimesi ile dizi oluşturulur ve boyutu belirlenir:</p><pre><code class="language-csharp">myArray = new int[10]; // 10 elemanlı bir dizi oluşturur.
</code></pre><p>Dizinin her bir elemanına değer atamak için indeks kullanılır:</p><pre><code class="language-csharp">myArray[0] = 5; // Dizinin ilk elemanına 5 değerini atar.
</code></pre><h2>Dizi İlk Atama</h2><p>Diziyi tanımlarken doğrudan içeriğini de belirleyebilirsiniz:</p><pre><code class="language-csharp">int[] myArray = { 1, 2, 3, 4, 5 };
</code></pre><p>Bu örnekte, 5 elemanlı <code>myArray</code> isimli bir dizi oluşturulmuş ve değerler atanmıştır.</p><h2>Dizi Üzerinde İşlemler</h2><h3>Dizi Boyutu</h3><p>Bir dizinin boyutunu <code>.Length</code> özelliği ile öğrenebilirsiniz:</p><pre><code class="language-csharp">Console.WriteLine(myArray.Length); // Dizinin boyutunu yazdırır.
</code></pre><h3>Dizi Elemanlarını Yazdırma</h3><p>Dizi elemanlarını yazdırmak için genellikle bir döngü kullanılır:</p><pre><code class="language-csharp">for (int i = 0; i &lt; myArray.Length; i++) {
    Console.WriteLine(myArray[i]);
}
</code></pre><p>Bu örnekte, <code>myArray</code> dizisinin tüm elemanları sırayla yazdırılır.</p><h2>Özel Durumlar ve Hatalar</h2><p>Bir dizinin boyutu oluşturulduktan sonra değiştirilemez ve dizi dışındaki bir indekse erişmeye çalışmak <code>IndexOutOfRangeException</code> hatasına neden olur.</p><h2>Dizilerin Faydaları</h2><ul><li><p>Birden fazla öğeyi tek bir değişken altında gruplandırma imkanı sunar.</p></li><li><p>Döngüler ile birlikte kullanıldığında, toplu işlemler yapmayı kolaylaştırır.</p></li></ul><h2>Sonuç</h2><p>C# programlama dilinde diziler, veri koleksiyonlarını yönetmek için güçlü araçlardır. Veri setleri üzerinde işlem yaparken, dizilerin sağladığı yapısal avantajlar sayesinde kodunuz daha düzenli ve anlaşılır hale gelir.</p>

C# ile Diziler (Arrays)

<p>C# programlama dilinde, <code>StringBuilder</code> sınıfı, metinler üzerinde değişiklik yapmayı ve büyük metin işlemleri gerçekleştirmeyi kolaylaştıran bir yapıdır. Normal stringler (<code>System.String</code>) C# dilinde immutable yani değiştirilemezdir. Bu, bir string üzerinde değişiklik yapmak istediğinizde aslında yeni bir string oluşturulduğu ve eski stringin bellekten silindiği anlamına gelir. Büyük ve sık metin işlemleri yapılırken, bu durum performans sorunlarına yol açabilir. <code>StringBuilder</code> sınıfı ise mutable yani değiştirilebilir stringler sağlar, böylece aynı string üzerinde yapılan değişiklikler yeni bir string oluşturmadan gerçekleştirilebilir.</p><h2>StringBuilder Tanımlama</h2><p><code>StringBuilder</code> nesnesi, <code>System.Text</code> ad alanı altında yer alır ve yeni bir <code>StringBuilder</code> nesnesi oluşturmak için aşağıdaki gibi bir kod kullanılır:</p><pre><code class="language-csharp">StringBuilder stringBuilder = new StringBuilder();
</code></pre><h2>StringBuilder'a Metin Ekleme</h2><p><code>StringBuilder</code>'a metin eklemek için <code>.Append()</code> metodu kullanılır:</p><pre><code class="language-csharp">stringBuilder.Append("Bu bir StringBuilder örneğidir.");
Console.WriteLine(stringBuilder.ToString()); // "Bu bir StringBuilder örneğidir."
</code></pre><h2>Metin Biçimlendirme ve Ekleme</h2><p><code>StringBuilder</code> ile <code>.AppendFormat()</code> metodu kullanılarak biçimlendirilmiş metinler de eklenebilir:</p><pre><code class="language-csharp">stringBuilder.AppendFormat("Merhaba, benim adım {0} ve {1} yaşındayım.", "Ali", 30);
Console.WriteLine(stringBuilder.ToString());
</code></pre><h2>StringBuilder'dan Metin Çıkarma ve Değiştirme</h2><p>Metin çıkarmak için <code>.Remove()</code> metodu, metin değiştirmek için ise <code>.Replace()</code> metodu kullanılır:</p><pre><code class="language-csharp">// Metin Çıkarma
stringBuilder.Remove(0, 3); // İlk 3 karakteri çıkarır.

// Metin Değiştirme
stringBuilder.Replace("Ali", "Veli");
</code></pre><h2>StringBuilder'ı Temizleme</h2><p><code>StringBuilder</code> içindeki tüm metni temizlemek için <code>.Clear()</code> metodu kullanılır:</p><pre><code class="language-csharp">stringBuilder.Clear();
</code></pre><h2>Performans</h2><p><code>StringBuilder</code> özellikle döngüler içinde veya bir string üzerinde çok sayıda değişiklik yapılacağı zaman tercih edilir. Çünkü, her değişiklikte yeni bir string oluşturmak yerine mevcut string üzerinde değişiklik yapılmasını sağlayarak bellek kullanımını ve işlemci yükünü azaltır.</p><h2>Özet</h2><p><code>StringBuilder</code>, C# programlama dilinde metin işlemlerini daha verimli hale getiren bir yapıdır. Mutable olması sayesinde, büyük ve karmaşık metin işlemlerinde performansı artırır. <code>.Append()</code>, <code>.AppendFormat()</code>, <code>.Remove()</code>, <code>.Replace()</code>, ve <code>.Clear()</code> gibi metotları ile metinler üzerinde çeşitli işlemler gerçekleştirmeyi sağlar. Özellikle sık metin değişikliği gerektiren durumlarda <code>StringBuilder</code> kullanımı tercih edilir.</p>

C# ile StringBuilder Kullanımı

<p>C# programlama dilinde stringler, karakter dizileridir ve metinsel verileri işlemek için kullanılırlar. Bir string, çeşitli karakterlerin bir araya gelmesiyle oluşur ve çift tırnak (" ") içerisinde tanımlanır. Stringlerle birlikte, metin üzerinde çeşitli işlemler yapmamıza olanak tanıyan birçok metod ve özellik gelir.</p><h2>String Tanımlama</h2><p>Bir string değişkeni tanımlamak için <code>string</code> anahtar kelimesi kullanılır:</p><pre><code class="language-csharp">string cumle = "Bugün güzel bir gün.";
</code></pre><h2>String Metodları ve Özellikleri</h2><h3>String Uzunluğu</h3><p>Bir string'in uzunluğunu <code>.Length</code> özelliği ile bulabilirsiniz:</p><pre><code class="language-csharp">Console.WriteLine(cumle.Length); // Çıktı: karakter sayısı
</code></pre><h3>Karakterlere Erişim</h3><p>String içerisindeki belirli bir karaktere erişmek için indeks kullanılır:</p><pre><code class="language-csharp">Console.WriteLine(cumle[0]); // İlk karakteri yazdırır, çıktı: 'B'
</code></pre><h3>String İçinde Arama</h3><p>Bir alt string'in (substring) başladığı ilk indeksi bulmak için <code>.IndexOf()</code> metodunu kullanabilirsiniz:</p><pre><code class="language-csharp">Console.WriteLine(cumle.IndexOf("güzel")); // Çıktı: bulunan indeks
</code></pre><h3>String Karşılaştırma</h3><p>İki string'in içeriğinin aynı olup olmadığını kontrol etmek için <code>.Equals()</code> metodunu kullanabilirsiniz:</p><pre><code class="language-csharp">string baskaCumle = "Bugün güzel bir gün.";
Console.WriteLine(cumle.Equals(baskaCumle)); // Çıktı: True veya False
</code></pre><h3>Boş ve Boşluk Kontrolü</h3><p>Bir string'in boş olup olmadığını kontrol etmek için <code>String.IsNullOrEmpty()</code> ve <code>String.IsNullOrWhiteSpace()</code> metodları kullanılabilir:</p><pre><code class="language-csharp">Console.WriteLine(String.IsNullOrEmpty(cumle)); // False
Console.WriteLine(String.IsNullOrWhiteSpace(cumle)); // False
</code></pre><h3>String Değiştirme</h3><p>Bir string içerisindeki belirli bir alt string'i başka bir alt string ile değiştirmek için <code>.Replace()</code> metodunu kullanabilirsiniz:</p><pre><code class="language-csharp">Console.WriteLine(cumle.Replace("güzel", "harika")); // "Bugün harika bir gün."
</code></pre><h3>String Kesme</h3><p>Bir string'in belirli bir bölümünü kesmek için <code>.Substring()</code> metodunu kullanabilirsiniz:</p><pre><code class="language-csharp">Console.WriteLine(cumle.Substring(6, 5)); // "güzel"
</code></pre><h3>Özel Karakterler</h3><p>Stringler içerisinde özel karakterler kullanmak istediğinizde, ters bölü (<code>\\\\</code>) işareti kullanılır. Örneğin, yeni bir satıra geçmek için <code>\\\\n</code>, tab karakteri için <code>\\\\t</code> kullanılır:</p><pre><code class="language-csharp">string ozelCumle = "Bu birinci satır.\\\\nBu ikinci satır.";
Console.WriteLine(ozelCumle);
</code></pre><h2>Sonuç</h2><p>C# dilinde stringler, metinsel veriler üzerinde işlem yapmamızı sağlayan güçlü araçlardır. Stringlerle birlikte gelen metodlar ve özellikler, metin manipülasyonu, karşılaştırma, arama ve değiştirme gibi birçok işlemi kolaylıkla yapmamıza olanak tanır. Bu özellikler, günlük programlama görevlerinde sıkça kullanılır ve C# dilinde metin işleme yeteneklerini genişletir.</p>

C# ile Strings

<p>C# programlama dilinde <code>for</code> döngüsü, belirli bir koşul doğru olduğu sürece belirlenen kod bloğunu tekrar tekrar çalıştırır. <code>for</code> döngüsü, başlangıçta bir sayaç değeri atar, her iterasyonda bu sayacı günceller ve bir koşul ifadesine dayanarak döngünün devam edip etmeyeceğine karar verir.</p><h2><code>for</code> Döngüsünün Yapısı</h2><p><code>for</code> döngüsünün temel yapısı şu şekildedir:</p><pre><code class="language-csharp">for (başlangıç; koşul; artırım) {
    // Kod Bloğu
}
</code></pre><ul><li><p><strong>Başlangıç:</strong> Döngünün başında sayaç değişkeni için bir başlangıç değeri atar.</p></li><li><p><strong>Koşul:</strong> Her döngü iterasyonundan önce bu koşul kontrol edilir. Koşul <code>true</code> ise, döngü içindeki kod bloğu çalıştırılır.</p></li><li><p><strong>Artırım:</strong> Kod bloğu her çalıştığında sayaç değişkeni belirtilen şekilde artırılır veya azaltılır.</p></li></ul><h2>Basit Bir <code>for</code> Döngüsü Örneği</h2><p>Örneğin, 0'dan başlayıp 9'a kadar olan sayıları yazdırmak istediğimizi düşünelim:</p><pre><code class="language-csharp">for (int i = 0; i &lt; 10; i++) {
    Console.WriteLine(i);
}
</code></pre><p>Bu örnekte, <code>i</code> adında bir sayaç değişkeni 0 olarak başlatılır. <code>i &lt; 10</code> koşulu <code>true</code> olduğu sürece döngü çalışır ve her seferinde <code>i++</code> ifadesiyle <code>i</code> bir artırılır. Bu şekilde, <code>i</code> 10 olduğunda koşul <code>false</code> olur ve döngü sona erer.</p><h2>Döngü Sonrası Değişkenin Durumu</h2><p><code>for</code> döngüsü içinde tanımlanan <code>i</code> değişkeni döngü dışında kullanılamaz. Eğer <code>i</code>'nin değerini döngü sonrası da kullanmak isterseniz, <code>i</code>'yi döngüden önce tanımlamanız gerekir:</p><pre><code class="language-csharp">int i;
for (i = 0; i &lt;= 10; i++) {
    Console.WriteLine(i);
}
// Döngü bittikten sonra i'nin değeri:
Console.WriteLine("Döngü bitti, i'nin son değeri: " + i); // 11 olur
</code></pre><p>Bu örnekte, <code>i</code> döngü dışında tanımlandığı için, döngü sonrasında <code>i</code>'nin son değerine erişebiliriz ve <code>i</code>, 10'dan sonraki ilk değer olan 11 olarak yazdırılır.</p><h2>Sonuç</h2><p><code>for</code> döngüsü, belirli bir koşul altında belirli bir kod bloğunu belirli bir sayıda çalıştırmak istediğinizde kullanışlıdır. Özellikle, bir koleksiyon veya dizi üzerinde işlem yaparken ya da belirli bir sayıda tekrar gerektiren durumlarda tercih edilir. Bu döngü tipi, programlama dillerinin çoğunda bulunan ve program akış kontrolü için temel yapı taşlarından biridir.</p>

C# ile for Döngüsü

<p><code>while</code> döngüsü, C# programlama dilinde koşula bağlı olarak bir kod bloğunu tekrar tekrar çalıştırmak için kullanılır. <code>while</code> döngüsünün temel mantığı oldukça basittir: Belirtilen koşul <code>true</code> olduğu sürece döngü içindeki kod bloğu çalıştırılır.</p><h3><code>while</code> Döngüsünün Yapısı</h3><pre><code class="language-csharp">while (koşul) {
    // Koşul true olduğu sürece bu blok çalışır
}
</code></pre><p><code>while</code> döngüsünde, döngü başlamadan önce koşul kontrol edilir. Eğer koşul doğru (<code>true</code>) ise, döngü içindeki kod bloğu çalıştırılır. Her iterasyondan sonra koşul tekrar kontrol edilir ve bu, koşul yanlış (<code>false</code>) olana kadar devam eder.</p><h3><code>while</code> Döngüsü Örneği</h3><p>Örneğin, bir değişkenin değeri 10'a ulaşana kadar onu artırmak istediğimizi düşünelim:</p><pre><code class="language-csharp">int k = 0; // Başlangıç değeri olarak 0 atadık.
while (k &lt; 10) {
    Console.WriteLine($"k'nin şu anki değeri: {k}");
    k++; // k değişkenini her döngüde bir artırıyoruz.
}
</code></pre><p>Bu örnekte, <code>k</code> değişkeni 0'dan başlar ve <code>k &lt; 10</code> koşulu <code>true</code> olduğu sürece döngü devam eder. Her döngüde <code>k</code> bir arttırılır, böylece <code>k</code> değeri 10 olduğunda döngü sona erer.</p><h3><code>while</code> vs. <code>do-while</code></h3><p><code>while</code> döngüsünün önemli bir özelliği, döngüye girilmeden önce koşulun kontrol edilmesidir. Bu, koşul baştan yanlışsa, döngü içindeki kod bloğunun hiç çalışmayacağı anlamına gelir. Örneğin, <code>k</code>'nın başlangıç değeri 10'dan büyük veya eşitse, yukarıdaki <code>while</code> döngüsü hiçbir işlem yapmaz.</p><p>Buna karşılık, <code>do-while</code> döngüsü, döngü bloğunu en az bir kez çalıştırmayı garanti eder çünkü koşul kontrolü, döngü bloğu çalıştıktan sonra yapılır. Bu nedenle, kodunuzun duruma bağlı olarak en az bir kez çalışmasını istiyorsanız <code>do-while</code> kullanmak daha uygun olabilir.</p><h3>Sonuç</h3><p><code>while</code> döngüsü, koşullu işlemleri tekrar etmek için C# programlamada sıkça kullanılan bir yapıdır. Koşulun döngüye girilmeden önce kontrol edilmesi, bu döngü türünü özellikle belirli bir koşul sağlanana kadar kodu tekrar etmek istediğiniz durumlar için uygun kılar. Ancak, koşulun döngü içinde değiştirilmediği durumlarda sonsuz döngüler oluşabileceği için dikkatli olmak gerekir.</p>

C# ile while Döngüsü

<p>Döngüler, programlama dilinde belirli bir kod blokunun tekrar tekrar çalıştırılmasını sağlayan yapılardır. Bir döngü, belirli bir koşul sağlandığı sürece kod bloğunu tekrarlar. Bu, aynı veya benzer işlemleri çok sayıda kez yapmamız gerektiğinde çok yararlıdır. Örneğin, bir dizi içindeki her eleman üzerinde işlem yapmak veya belirli bir koşula ulaşıncaya kadar bir işlemi tekrar etmek için döngüler kullanılabilir.</p><p>C# dilinde çeşitli döngü türleri bulunur:</p><ul><li><p><code>do-while</code> Döngüsü</p></li><li><p><code>for</code> Döngüsü</p></li><li><p><code>while</code> Döngüsü</p></li></ul><p>Her bir döngü türü, farklı senaryolar için uygundur ve kullanımı senaryonun gereksinimlerine göre değişir.</p><h2><code>do-while</code> Döngüsü: Kod Örneğiyle Açıklama</h2><p><code>do-while</code> döngüsü, döngü koşulu kontrol edilmeden önce döngü içindeki kodun en az bir kez çalıştırılmasını sağlar. Yani, koşul sonradan kontrol edilir ve bu koşul <code>true</code> (doğru) olduğu sürece döngü devam eder.</p><pre><code class="language-csharp">int k = 0; // Başlangıç değeri
do {
    Console.WriteLine($"k'nin değeri: {k}"); // k'nin mevcut değerini yazdır
    k++; // k'nin değerini bir artır
} while (k &lt; 10); // k'nin değeri 10'dan küçük olduğu sürece döngüyü tekrarla

</code></pre><p>Bu örnekte, <code>k</code> değişkeni 0 ile başlar ve her döngüde 1 arttırılır. <code>k</code>'nin değeri 10'a ulaştığında, <code>while</code> koşulu <code>false</code> olur ve döngü sona erer. Böylece, ekrana "k'nin değeri: x" cümlesi, <code>k</code> 10 olana kadar her değer için yazdırılır.</p><p>Önemli bir nokta, <code>do-while</code> döngüsünün özelliği gereği, döngü içindeki kodun koşul ne olursa olsun en az bir kez çalıştırılacak olmasıdır. Bu yüzden, <code>k</code> başlangıçta 10 veya daha büyük bir değere sahip olsa bile, döngü içindeki kod bloğu bir kez çalışır, sonra koşul kontrol edilir ve döngü sona erer.</p><h2>Sonuç</h2><p>C# programlamada döngüler, kod tekrarını azaltmak, program akışını etkin bir şekilde yönetmek ve belirli bir koşula kadar veya bir koleksiyondaki her eleman için işlemleri tekrarlamak için kullanılır. <code>do-while</code> döngüsü, koşulun sonradan kontrol edildiği ve döngü bloğunun mutlaka en az bir kez çalıştırıldığı özel bir döngü türüdür. Bu, bazı senaryolarda, özellikle de işlem en az bir kez yapılmalıyken kullanışlıdır.</p>

C# ile Döngüler (Loops) ve C# Do While Döngüsü

<p>C# programlama dilinde üçlü (ternary) operatör, koşullu ifadeleri daha kısa ve okunaklı bir şekilde yazmanızı sağlayan bir yapıdır. Temelde, <code>if-else</code> yapısının bir kısaltması olarak düşünülebilir. Üçlü operatör, bir koşulu değerlendirir ve koşul <code>true</code> ise belirtilen bir değeri, <code>false</code> ise başka bir değeri döndürür. Bu yapı, <code>[koşul] ? [doğruysa değer] : [yanlışsa değer]</code> formatında kullanılır.</p><h2>Temel Syntax</h2><p>Üçlü operatörün genel kullanımı şu şekildedir:</p><pre><code class="language-csharp">var sonuc = koşul ? değer1 : değer2;
</code></pre><p>Eğer <code>koşul</code> <code>true</code> ise <code>değer1</code>, <code>false</code> ise <code>değer2</code> <code>sonuc</code> değişkenine atanır.</p><h2>Örnek Kullanım</h2><p>Yaşa bağlı olarak bir kişinin yüzebilir olup olmadığını kontrol eden bir örnek üzerinden gidelim:</p><pre><code class="language-csharp">int yas = 4;
var yuzebilirMi = yas &gt; 10 ? "Evet" : "Hayır";
Console.WriteLine(yuzebilirMi); // "Hayır"
</code></pre><p>Bu örnekte, <code>yas</code> değişkeninin değeri 4 olduğu için <code>yas &gt; 10</code> koşulu <code>false</code> değerlendirilir ve <code>yuzebilirMi</code> değişkenine <code>"Hayır"</code> atanır. Eğer <code>yas</code> değerini 40 olarak değiştirirsek:</p><pre><code class="language-csharp">int yas = 40;
var yuzebilirMi = yas &gt; 10 ? "Evet" : "Hayır";
Console.WriteLine(yuzebilirMi); // "Evet"
</code></pre><p>Bu durumda, koşul <code>true</code> olduğu için <code>yuzebilirMi</code> değişkenine <code>"Evet"</code> değeri atanır ve konsola bu değer yazdırılır.</p><h2>Üçlü Operatörün Avantajları</h2><ul><li><p><strong>Kısalık ve Okunabilirlik:</strong> Koşullu ifadeleri tek bir satırda yazmanızı sağlayarak kodunuzu daha sade ve anlaşılır hale getirir.</p></li><li><p><strong>Kod Düzeni:</strong> Basit <code>if-else</code> yapıları için daha düzenli bir alternatif sunar.</p></li><li><p><strong>Atamalar ve Dönüşler:</strong> Değer atamalarında ve fonksiyonlardan değer döndürürken pratik bir çözüm sağlar.</p></li></ul><h2>Kullanım Sınırları</h2><p>Üçlü operatör, karmaşık koşullar ve çok sayıda koşullu durum içeren senaryolarda kullanıldığında, kodun okunabilirliğini olumsuz etkileyebilir. Bu durumlarda, geleneksel <code>if-else</code> yapıları tercih edilmelidir.</p><h2>Sonuç</h2><p>C# programlama dilinde üçlü (ternary) operatör, basit koşullu ifadeleri yazmak için etkili ve okunaklı bir alternatif sunar. Ancak, karmaşık koşullar için geleneksel <code>if-else</code> yapılarının kullanılması, kodun anlaşılırlığı açısından önemlidir.</p>

C# İle Üçlü (Ternary) Operatör Kullanımı

<p>C# programlama dilinde koşullu ifadeler, belirli bir koşulun doğruluğuna bağlı olarak farklı kod bloklarının çalıştırılmasını sağlar. Bu yapılar, programın akışını dinamik bir şekilde yönetmek ve farklı durumlara uygun çözümler üretmek için kullanılır. Koşullu ifadeler, genellikle boolean (mantıksal) ifadelerle birlikte kullanılır ve temel olarak <code>if</code>, <code>else if</code>, ve <code>else</code> anahtar kelimeleri ile oluşturulur.</p><h2><code>if</code> İfadesi</h2><p><code>if</code> ifadesi, belirli bir koşulun <code>true</code> (doğru) olup olmadığını kontrol eder. Eğer koşul <code>true</code> ise <code>if</code> bloğu içerisindeki kodlar çalıştırılır:</p><pre><code class="language-csharp">bool a = true;
if (a) {
    Console.WriteLine("a doğru.");
}
</code></pre><p>Bu örnekte, <code>a</code> değişkeni <code>true</code> olarak tanımlandığı için konsola "a doğru." mesajı yazdırılır.</p><h2><code>else</code> İfadesi</h2><p><code>else</code> ifadesi, <code>if</code> koşulu <code>false</code> olduğunda çalışacak kod bloğunu tanımlar:</p><pre><code class="language-csharp">bool a = false;
if (a) {
    Console.WriteLine("a doğru.");
} else {
    Console.WriteLine("a yanlış.");
}
</code></pre><p>Bu durumda, <code>a</code> <code>false</code> olduğu için "a yanlış." mesajı yazdırılır.</p><h2><code>else if</code> İfadesi</h2><p><code>else if</code> ifadesi, birden fazla koşulu sırayla kontrol etmek için kullanılır. <code>if</code> koşulu <code>false</code> ise, <code>else if</code> blokları sırasıyla kontrol edilir. Eğer bir <code>else if</code> koşulu <code>true</code> ise, ilgili blok çalıştırılır ve diğer <code>else if</code> blokları atlanır:</p><pre><code class="language-csharp">int b = 20;
if (b &lt; 15) {
    Console.WriteLine("b, 15'ten küçük.");
} else if (b &lt;= 15) {
    Console.WriteLine("b, 15'e eşit veya küçük.");
} else {
    Console.WriteLine("b, 15'ten büyük.");
}
</code></pre><p>Bu örnekte, <code>b</code> değişkeni 15'ten büyük olduğu için "b, 15'ten büyük." mesajı yazdırılır.</p><h2>Koşulların İç İçe Kullanımı (Nesting)</h2><p>Koşullu ifadeler iç içe kullanılabilir. Bu, daha karmaşık karar yapıları oluşturmak için kullanışlıdır:</p><pre><code class="language-csharp">bool a = true;
int b = 20;
if (a) {
    if (b &lt; 15) {
        Console.WriteLine("a doğru ve b, 15'ten küçük.");
    } else {
        Console.WriteLine("a doğru ve b, 15'ten büyük veya eşit.");
    }
} else {
    Console.WriteLine("a yanlış.");
}
</code></pre><p>Bu yapıda, öncelikle <code>a</code> değişkeninin değeri kontrol edilir. Eğer <code>a</code> <code>true</code> ise, <code>b</code> değişkeninin değeri kontrol edilir ve uygun mesaj yazdırılır. Eğer <code>a</code> <code>false</code> olsaydı, direkt olarak "a yanlış." mesajı yazdırılacaktı.</p><h2>Sonuç</h2><p>C# programlama dilinde koşullu ifadeler, programların mantıksal akışını etkin bir şekilde yönetmek için hayati öneme sahiptir. <code>if</code>, <code>else if</code>, ve <code>else</code> anahtar kelimeleri ile birlikte, bu yapılar sayesinde farklı koşullara göre farklı işlemler gerçekleştirilebilir. Bu yapıların anlaşılması ve etkin bir şekilde kullanılması, dinamik ve esnek programlar geliştirmek için gereklidir.</p>

C# İle Koşullu İfadeler (Conditionals)

<p>C# programlama dilinde, boolean ifadeler ve karşılaştırmalar, koşullu durumların kontrolünde temel yapı taşlarından biridir. Bu ifadeler, genellikle <code>true</code> veya <code>false</code> değerlerini alır ve programın akışını kontrol etmek için kullanılır. Bu yazıda, temel karşılaştırma operatörleri, mantıksal operatörler ve bunların nasıl kullanılacağı üzerinde duracağız.</p><h2>Temel Karşılaştırma Operatörleri</h2><ul><li><p><code>&gt;</code> (büyüktür)</p></li><li><p><code>&lt;</code> (küçüktür)</p></li><li><p><code>&gt;=</code> (büyük eşittir)</p></li><li><p><code>&lt;=</code> (küçük eşittir)</p></li><li><p><code>==</code> (eşittir)</p></li><li><p><code>!=</code> (eşit değildir)</p></li></ul><pre><code class="language-csharp">int x = 6;
Console.WriteLine(x &gt; 1); // True
Console.WriteLine(x &lt; 10); // True
</code></pre><h2>Mantıksal Operatörler</h2><p>C# içerisinde, birden fazla boolean ifadeyi birleştirmek için mantıksal operatörler kullanılır:</p><ul><li><p><code>&amp;&amp;</code> (ve): İki koşul da <code>true</code> ise sonuç <code>true</code> olur.</p></li><li><p><code>||</code> (veya): İki koşuldan en az biri <code>true</code> ise sonuç <code>true</code> olur.</p></li><li><p><code>!</code> (değil): Koşulun tersini alır. Eğer koşul <code>true</code> ise <code>false</code> yapar, <code>false</code> ise <code>true</code> yapar.</p></li></ul><pre><code class="language-csharp">Console.WriteLine(x &gt; 1 &amp;&amp; x &lt; 10); // x, 1'den büyük VE 10'dan küçük mü?
// True, çünkü x hem 1'den büyük hem de 10'dan küçük.

Console.WriteLine(x &gt; 10 || x &lt; 5); // x, 10'dan büyük VEYA 5'ten küçük mü?
// False, çünkü x ne 10'dan büyük ne de 5'ten küçük.

Console.WriteLine(!(x &lt; 5)); // x, 5'ten küçük değil mi?
// True, çünkü x 5'ten küçük değil (x 5'ten büyük).
</code></pre><h2>Eşitlik ve Eşit Olmama</h2><p>Bir değişkenin değerini başka bir değerle karşılaştırmak için <code>==</code> ve <code>!=</code> operatörleri kullanılır:</p><pre><code class="language-csharp">Console.WriteLine(x == 6); // x, 6'ya eşit mi? True
Console.WriteLine(x != 5); // x, 5'e eşit değil mi? True
</code></pre><h2>Aralık Kontrolü</h2><p>Bir sayının belirli bir aralıkta olup olmadığını kontrol etmek istediğinizde, <code>&amp;&amp;</code> operatörünü kullanarak iki karşılaştırmayı birleştirebilirsiniz:</p><pre><code class="language-csharp">Console.WriteLine(x &gt; 1 &amp;&amp; x &lt; 10); // x, 1 ile 10 arasında mı? True
</code></pre><p>Bu örnekte, <code>x</code> değeri 6 olduğu için, 1 ile 10 arasında olduğunu ve bu durumun <code>true</code> olarak değerlendirildiğini görebiliriz.</p><h2>Sonuç</h2><p>C# programlama dilinde, boolean ifadeler ve karşılaştırmalar, programın akışını kontrol etmek, koşullu ifadeler oluşturmak ve mantıksal kararlar almak için hayati önem taşır. Temel karşılaştırma operatörleri ve mantıksal operatörler, bu tür kontrol mekanizmalarının temelini oluşturur. Uygulamalarınızda, bu operatörleri etkili bir şekilde kullanarak daha dinamik ve koşullu mantıklar geliştirebilirsiniz.</p>

C# İle Boolean İfadeler ve Karşılaştırmalar

<p>C# programlama dilinde, matematiksel hesaplamalar ve fonksiyonlar için <code>System.Math</code> sınıfı geniş bir yelpazede fonksiyon ve sabit sağlar. Bu yazıda, trigonometrik fonksiyonlar, mutlak değer hesaplama, minimum ve maksimum değer bulma, karekök ve üs alma gibi ileri düzey matematik işlemlerini ele alacağız.</p><h2>Trigonometrik Fonksiyonlar</h2><p>Trigonometrik fonksiyonlar, geometride ve dalgaların incelenmesinde sıklıkla kullanılan fonksiyonlardır. C# içerisinde, <code>Math</code> sınıfı bu fonksiyonları sağlar:</p><pre><code class="language-csharp">double x = 5.3;
Console.WriteLine("Cos(x): " + Math.Cos(x)); // x'in kosinüs değeri

x = 3.14; // Yaklaşık olarak Pi değeri
Console.WriteLine("Cos(x): " + Math.Cos(x)); // x'in kosinüs değeri, yaklaşık olarak -1

// Pi'nin kesin değeri
Console.WriteLine("Cos(Math.PI): " + Math.Cos(Math.PI)); // Cos(Math.PI), -1 değerini verir

// Sinüs ve tanjant fonksiyonları
Console.WriteLine("Sin(x): " + Math.Sin(x));
Console.WriteLine("Tan(x): " + Math.Tan(x));

// Hiperbolik trigonometrik fonksiyonlar
Console.WriteLine("Cosh(x): " + Math.Cosh(x)); // Hiperbolik kosinüs
Console.WriteLine("Sinh(x): " + Math.Sinh(x)); // Hiperbolik sinüs
Console.WriteLine("Tanh(x): " + Math.Tanh(x)); // Hiperbolik tanjant
</code></pre><h2>Mutlak Değer</h2><p>Mutlak değer, bir sayının sıfıra olan uzaklığını gösterir. Negatif bir sayının mutlak değeri pozitiftir:</p><pre><code class="language-csharp">double negatifX = -5.3;
Console.WriteLine("Abs(x): " + Math.Abs(negatifX)); // x'in mutlak değeri
</code></pre><h2>Minimum ve Maksimum Değerler</h2><p>İki sayı arasından minimum veya maksimum olanı seçmek için <code>Math.Min</code> ve <code>Math.Max</code> fonksiyonları kullanılır:</p><pre><code class="language-csharp">double y = x + 2;
Console.WriteLine("Min(x, y): " + Math.Min(x, y)); // x ve y arasındaki minimum değer
Console.WriteLine("Max(x, y): " + Math.Max(x, y)); // x ve y arasındaki maksimum değer
</code></pre><h2>Karekök ve Üs Alma</h2><p>Bir sayının karekökünü almak veya bir sayıyı bir üssüne yükseltmek için <code>Math.Sqrt</code> ve <code>Math.Pow</code> fonksiyonları kullanılır:</p><pre><code class="language-csharp">Console.WriteLine("Sqrt(x): " + Math.Sqrt(x)); // x'in karekökü

// x'i 2. kuvvetine yükseltmek
Console.WriteLine("Pow(x, 2): " + Math.Pow(x, 2)); // x^2
</code></pre><h2>Yuvarlama İşlemleri</h2><p>Bir sayıyı aşağı veya yukarı yuvarlamak için <code>Math.Floor</code> ve <code>Math.Ceiling</code> fonksiyonları kullanılır:</p><pre><code class="language-csharp">Console.WriteLine("Floor(x): " + Math.Floor(x)); // x'ten küçük en büyük tamsayı
Console.WriteLine("Ceiling(x): " + Math.Ceiling(x)); // x'ten büyük en küçük tamsayı
</code></pre><h2>Sonuç</h2><p>C# programlama dilinde, <code>System.Math</code> sınıfı ile birçok ileri düzey matematik işlemi gerçekleştirilebilir. Trigonometrik hesaplamalar, mutlak değer, minimum ve maksimum değerler, karekök ve üs alma gibi işlemler bu sınıfın sağladığı fonksiyonlarla kolaylıkla yapılabilir. Matematiksel hesaplamalar, mühendislikten finansa, birçok alanda uygulama bulur ve C#'da bu işlemleri yapmak için gerekli araçlar mevcuttur.</p>

C# ile İleri Düzey Matematik İşlemleri

<p>C# programlama dilinde, temel matematik işlemleri yapmak oldukça basit ve doğrudandır. Bu yazıda, toplama, çıkarma, çarpma, bölme, ve mod alma gibi temel işlemlerin yanı sıra, artırma ve azaltma işlemleri üzerinde duracağız. Ayrıca, veri tipleri arasında dönüşüm yapmanın (casting) nasıl gerçekleştirileceğini de gözden geçireceğiz.</p><h2>Toplama İşlemi</h2><p>Toplama işlemi, iki veya daha fazla sayının bir araya getirilerek toplam değerinin bulunmasıdır. C# dilinde <code>+</code> operatörü ile kolayca gerçekleştirilir:</p><pre><code class="language-csharp">Console.WriteLine("6 + 3 = " + (6 + 3)); // Çıktı: 6 + 3 = 9</code></pre><h2>Çıkarma İşlemi</h2><p>Çıkarma işlemi, bir sayıdan diğer bir sayının çıkarılmasıdır ve <code>-</code> operatörü kullanılarak yapılır:</p><pre><code class="language-csharp">Console.WriteLine("6 - 3 = " + (6 - 3)); // Çıktı: 6 - 3 = 3</code></pre><h2>Çarpma İşlemi</h2><p>Çarpma işlemi, iki sayının birbirleriyle çarpılması işlemidir ve <code>*</code> operatörü ile gerçekleştirilir:</p><pre><code class="language-csharp">Console.WriteLine("6 * 3 = " + (6 * 3)); // Çıktı: 6 * 3 = 18</code></pre><h2>Bölme İşlemi</h2><p>Bölme işlemi, bir sayının diğer sayıya bölünmesi işlemidir ve <code>/</code> operatörü kullanılır. Bölme işlemi yapılırken, bölünen ve bölenin veri tipine dikkat etmek önemlidir çünkü tam sayılar arasında bölme yapıldığında sonuç tam sayı olarak döner ve ondalık kısım atılır:</p><pre><code class="language-csharp">Console.WriteLine("6 / 4 = " + (6 / 4)); // Çıktı: 6 / 4 = 1
// Double tipine cast ederek doğru sonucu almak:
Console.WriteLine("6 / 4 = " + (6.0 / 4)); // Çıktı: 6 / 4 = 1.5</code></pre><h2>Mod Alma (Kalanı Bulma)</h2><p>Mod alma işlemi, bir sayının başka bir sayıya bölünmesi sonucunda kalanı bulma işlemidir ve <code>%</code> operatörü ile yapılır:</p><pre><code class="language-csharp">Console.WriteLine("6 % 4 = " + (6 % 4)); // Çıktı: 6 % 4 = 2</code></pre><h2>Artırma ve Azaltma İşlemleri</h2><p>C# dilinde, bir değişkenin değerini bir artırmak için <code>++</code>, bir azaltmak için <code>--</code> operatörleri kullanılır. Bu operatörler, değişkenin önüne veya arkasına konularak kullanılabilir ve kullanım yerine göre değişkenin değeri önce mi sonra mı değiştirileceğini belirler:</p><pre><code class="language-csharp">int i = 1;
Console.WriteLine("i = " + i++); // Çıktı: i = 1, ardından i 2 olur
Console.WriteLine("i = " + ++i); // i önce 3 olur, çıktı: i = 3</code></pre><h2>Sonuç</h2><p>C# ile temel matematik işlemleri, programlama sırasında sıklıkla karşılaşılan durumlar için gerekli araçları sağlar. Bu işlemler, algoritma geliştirirken ve problemleri çözerken temel yapı taşlarından biridir. Veri tipleri arasındaki dönüşümler ve operatörlerin doğru kullanımı, beklenen sonuçların elde edilmesinde önemli rol oynar.</p>

C# ile Temel Matematik İşlemleri

<p>Bu yazıda, C# kullanarak nasıl ekrana çıktı verileceği ve kullanıcıdan giriş nasıl alınacağı üzerine odaklanacağız. Özellikle konsol uygulamalarında sıkça kullanılan <code>Console.WriteLine</code> ve <code>Console.ReadLine</code> metotlarını inceleyeceğiz.</p><h2>Ekrana Çıktı Verme</h2><p>Ekrana çıktı vermek için C#'da <code>Console.WriteLine</code> metodu kullanılır. Bu metod, içine yazılan metni konsol ekranına yazdırır. Eğer yazdırılacak metin sabit bir değerse, doğrudan metin olarak yazılabilir. Eğer değişken değerler veya hesaplamalar sonucu elde edilen değerler yazdırılacaksa, bu değerler <code>+</code> operatörü ile metne eklenerek yazdırılabilir.</p><pre><code class="language-csharp">Console.WriteLine("Hoş geldiniz!");
</code></pre><p>Yukarıdaki örnek, ekrana "Hoş geldiniz!" mesajını yazdırır.</p><h2>Kullanıcıdan Giriş Alma</h2><p>Kullanıcıdan giriş almak için <code>Console.ReadLine</code> metodu kullanılır. Bu metod, kullanıcının girdiği metni bir string olarak döndürür. Bu string, bir değişkene atanabilir ve programın diğer bölümlerinde kullanılabilir.</p><pre><code class="language-csharp">Console.Write("Lütfen adınızı giriniz: ");
string ad = Console.ReadLine();
Console.WriteLine("Merhaba, " + ad + "!");
</code></pre><p>Yukarıdaki kod, kullanıcıdan adını girmesini ister ve girilen adı kullanarak bir selamlama mesajı yazdırır.</p><h2>String Birleştirme</h2><p>C# içerisinde stringler, <code>+</code> operatörü kullanılarak birleştirilebilir. Bu, özellikle kullanıcıdan alınan girişlerle birlikte sabit metinlerin birleştirilip, kullanıcıya özelleştirilmiş çıktılar sunulmak istendiğinde kullanışlıdır.</p><pre><code class="language-csharp">string mesaj = "Merhaba, " + ad + "!";
Console.WriteLine(mesaj);
</code></pre><h2>Kullanıcı Etkileşimli Program</h2><p>Bir kullanıcı etkileşimli programın basit bir örneği:</p><pre><code class="language-csharp">Console.WriteLine("Hoş geldiniz, lütfen adınızı giriniz:");
string kullaniciAdi = Console.ReadLine();
Console.WriteLine("Merhaba, " + kullaniciAdi + ", nasılsınız?");
</code></pre><p>Bu kod parçası, kullanıcıya hoş geldin mesajı gösterir, adını ister ve daha sonra kullanıcının adını kullanarak ona özel bir mesaj gösterir.</p><h2>Sonuç</h2><p>C# ile kullanıcı girişi ve çıktısı yönetimi, konsol uygulamalarının temel taşlarından biridir. <code>Console.WriteLine</code> ve <code>Console.ReadLine</code> metotları, bu işlemleri gerçekleştirmek için sıkça kullanılan araçlardır. Kullanıcıdan alınan girişlerle dinamik çıktılar oluşturmak, programın kullanıcı dostu ve etkileşimli olmasını sağlar. Bu yazıda temel kullanıcı girişi ve çıktısı işlemleri üzerinde durduk. Bu bilgiler, C# ile konsol uygulamaları geliştirirken temel bir rehber olarak kullanılabilir.</p>

C# ile Kullanıcı Girişi ve Çıktısı (User IO)

<p>C# programlama dili, .NET Framework'ün bir parçası olarak Microsoft tarafından geliştirilmiştir. Güçlü tip denetimi, nesne yönelimli programlama, ve geniş kütüphane desteği gibi özellikleriyle dikkat çeker. C# içerisinde kullanılan veri tipleri, programlama sırasında verilerin doğru şekilde işlenmesini sağlar. Bu makalede, C#'da kullanılan temel veri tiplerini inceleyeceğiz.</p><h2>1- Tamsayılar (Integers)</h2><p>Tamsayılar, ondalık kısmı olmayan sayıları temsil eder. C#'da tamsayı değişkenleri <code>int</code> anahtar kelimesi ile tanımlanır. Örneğin, bir değişkene 1 değerini atamak için şu şekilde bir tanımlama yapılır:</p><pre><code class="language-csharp">int x = 1;
Console.WriteLine(x); // Çıktı: 1
</code></pre><p>Değer ataması yapıldıktan sonra <code>x</code> değişkeni, 1 değerini tutar. Bu değeri konsola yazdırmak için <code>Console.WriteLine(x);</code> ifadesi kullanılır.</p><p>C# dilinde tamsayıların alabileceği maksimum ve minimum değerler <code>int.MaxValue</code> ve <code>int.MinValue</code> özellikleri ile sorgulanabilir:</p><pre><code class="language-csharp">Console.WriteLine(int.MaxValue); // Maksimum int değeri
Console.WriteLine(int.MinValue); // Minimum int değeri
</code></pre><h2>2- Kayan Noktalı Sayılar (Floats)</h2><p>Kayan noktalı sayılar, ondalık kısmı olan sayıları temsil eder. <code>float</code> anahtar kelimesi ile tanımlanır ve değerlerin sonuna <code>f</code> veya <code>F</code> eklenir. Örneğin:</p><pre><code class="language-csharp">float y = 4.5f;
Console.WriteLine(y); // Çıktı: 4.5
</code></pre><p>Kayan noktalı sayıların maksimum ve minimum değerleri, <code>float.MaxValue</code> ve <code>float.MinValue</code> ile elde edilir. <code>float</code> veri tipi 32-bitlik bir yapıdadır ve yaklaşık 7 basamaklı bir doğruluk sunar.</p><p>Maksimum ve minimum <code>float</code> değerleri:</p><pre><code class="language-csharp">Console.WriteLine(float.MaxValue); // 3.402823E+38
Console.WriteLine(float.MinValue); // -3.402823E+38
</code></pre><h2>3- Çift Kayan Noktalı Sayılar (Doubles)</h2><p>Daha geniş bir aralık ve daha fazla doğruluk gerektiren durumlar için <code>double</code> veri tipi kullanılır. Örneğin:</p><pre><code class="language-csharp">double z = 5.9;
Console.WriteLine(z); // Çıktı: 5.9
</code></pre><p><code>double</code> veri tipi 64-bitlik bir yapıdadır ve yaklaşık 15-16 basamaklı bir doğruluk sunar. Maksimum ve minimum değerleri, <code>double.MaxValue</code> ve <code>double.MinValue</code> ile sorgulanabilir.</p><p>Maksimum ve minimum <code>double</code> değerleri:</p><pre><code class="language-csharp">Console.WriteLine(double.MaxValue); // 1.7976931348623157E+308
Console.WriteLine(double.MinValue); // -1.7976931348623157E+308
</code></pre><h2>4- Uzun Tamsayılar (Longs) ve Decimal</h2><p>Daha büyük tamsayı değerleri için <code>long</code> veri tipi, daha büyük ve daha hassas ondalık sayılar için ise <code>decimal</code> veri tipi kullanılır. <code>long</code> ve <code>decimal</code> veri tiplerinin maksimum ve minimum değerleri sırasıyla <code>long.MaxValue</code>, <code>long.MinValue</code>, <code>decimal.MaxValue</code> ve <code>decimal.MinValue</code> ile elde edilir.</p><p>Büyük tamsayılar için <code>long</code>, büyük ve hassas ondalık sayılar için <code>decimal</code> kullanılır:</p><pre><code class="language-csharp">long l = long.MaxValue;
Console.WriteLine(l); // 9223372036854775807

decimal d = decimal.MaxValue;
Console.WriteLine(d); // 79228162514264337593543950335
</code></pre><h2>5- Karakterler ve Dizgiler</h2><p>Karakterler <code>char</code> anahtar kelimesi ile tanımlanır ve tek tırnak içerisinde belirtilir. Tek bir karakteri hafızada tutmanız gerektiğinde kullanabilirsiniz.:</p><pre><code class="language-csharp">char karakter = 'e';
</code></pre><p>Dizgiler (stringler), karakterlerin dizilimi olarak tanımlanır ve çift tırnak kullanılarak oluşturulur:</p><pre><code class="language-csharp">string ad = "Ahmet";
</code></pre><h2>6- <code>var</code> ve <code>dynamic</code> Anahtar Kelimeleri</h2><p>C#'da, <code>var</code> anahtar kelimesi ile değişkenlerin türü derleme zamanında belirlenirken, <code>dynamic</code> anahtar kelimesi ile değişkenlerin türü çalışma zamanında belirlenir. <code>var</code> ile tanımlanan değişkenlerin türü, atanan ilk değere göre belirlenir ve sonrasında değiştirilemez. <code>dynamic</code> ile tanımlanan değişkenlerde ise tür, programın çalışma zamanında değişebilir:</p><pre><code class="language-csharp">var a = 5;
Console.WriteLine(a); // Çıktı: 5

dynamic b = "Merhaba";
Console.WriteLine(b); // Çıktı: Merhaba
b = 10;
Console.WriteLine(b); // Çıktı: 10
</code></pre><h2><strong>7- Sabitler (Constants) ile </strong><code>const</code> Kullanımı</h2><p><code>const</code> anahtar kelimesi, değeri programın çalışması sırasında değişmeyecek sabitleri tanımlamak için kullanılır. Örneğin, matematikte pi sayısının değeri sabittir ve değişmez. Bu tür sabit bir değeri <code>const</code> ile tanımlayabiliriz:</p><pre><code class="language-csharp">const double pi = 3.14159;
Console.WriteLine(pi); // Çıktı: 3.14159
</code></pre><p><code>const</code> ile tanımlanan bir değişkenin değeri sonradan değiştirilemez ve bu yüzden, programın farklı bölümlerinde güvenle kullanılabilir.</p><h2><strong>8- </strong><code>bool</code> Kullanımı</h2><p><code>bool</code> tipi yalnızca iki değer alabilir: <code>true</code> (doğru) veya <code>false</code> (yanlış). Bu veri tipi, koşullu ifadelerde, döngülerde ve mantıksal karşılaştırmalar yapılırken geniş bir kullanım alanına sahiptir. <code>bool</code> veri tipinin kullanımına ilişkin bazı temel örnekler bulunmaktadır:</p><pre><code class="language-csharp">bool dogru = true;
bool yanlis = false;

Console.WriteLine(dogru);  // Çıktı: True
Console.WriteLine(yanlis); // Çıktı: False
</code></pre><h2>Sonuç</h2><p>C#'da veri tipleri, programın doğru ve verimli bir şekilde çalışmasını sağlar. Her bir veri tipinin kullanım amacına uygun olarak seçilmesi, hafıza yönetimi ve performans açısından önemlidir. Bu makalede temel veri tipleri üzerinde durulmuş olup, daha derinlemesine bilgi edinmek için C# dökümantasyonlarından yararlanılabilir.</p>

C# Data Types (Veri Tipleri)

<p>Yazılım geliştirmeye yeni başladıysanız ve C# ile çalışmak istiyorsanız, Visual Studio mükemmel bir tercihtir. Bu, Microsoft tarafından geliştirilen zengin özelliklere sahip ve profesyonel bir entegre geliştirme ortamıdır (IDE). Bu rehberde, C# ve Visual Studio'yu adım adım nasıl kuracağınızı anlatacağız.</p><h3>Adım 1: Visual Studio’nun Kurulması</h3><p>Öncelikle Visual Studio'yu bilgisayarınıza kurmalısınız.</p><ol><li><p>Visual Studio'nun resmi web sitesine gidin: <a target="" rel="noopener noreferrer nofollow" href="http://visualstudio.microsoft.com">visualstudio.microsoft.com</a></p></li><li><p>"Download" sekmesine tıklayın ve "Community 2022" sürümünü seçin. (Kişisel veya küçük takım projeleri için ücretsizdir.)</p></li><li><p>İndirilen yükleyiciyi çalıştırın.</p></li><li><p>Kurulum sırasında, "<a target="" rel="noopener noreferrer nofollow" href="http://ASP.NET">ASP.NET</a> and web development" ve "Desktop development with C#" iş yüklerini seçin. Bu iş yükleri, web ve masaüstü uygulamaları geliştirmek için gerekli araç ve kütüphaneleri içerir.</p></li><li><p>"Install" seçeneğine tıklayarak kurulumu tamamlayın.</p></li></ol><h3>Adım 2: C# Projesi Oluşturma</h3><p>Visual Studio kurulumunuz tamamlandıktan sonra, ilk C# projenizi oluşturabilirsiniz.</p><ol><li><p>Visual Studio'yu açın.</p></li><li><p>"Create a new project" seçeneğine tıklayın.</p></li><li><p>Proje türü olarak "Console App (.NET Core)" seçeneğini aratın ve seçin. Console App, komut satırı uygulaması oluşturmanıza olanak tanır.</p></li><li><p>"Next" butonuna tıklayın.</p></li><li><p>Projenize bir isim verin ve bir konum seçin.</p></li><li><p>"Create" butonuna tıklayarak projenizi oluşturun.</p></li></ol><h3>Adım 3: İlk C# Programınızı Yazın ve Çalıştırın</h3><p>Projeniz oluşturulduktan sonra, Visual Studio'da kod yazmaya başlayabilirsiniz.</p><ol><li><p>Proje çözüm gezgininde "Program.cs" dosyasını açın. Bu dosya, C# kodunuzu yazacağınız yerdir.</p></li><li><p>Aşağıdaki basit C# kodunu yazın:</p></li></ol><pre><code class="language-csharp">using System;

namespace MyFirstApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Merhaba, Dünya!");
        }
    }
}</code></pre><ol><li><p>"Start" butonuna tıklayarak veya F5 tuşuna basarak programınızı çalıştırın.</p></li><li><p>Programınız çalıştırıldığında, bir komut penceresi açılacak ve "Merhaba, Dünya!" mesajını gösterecektir.</p></li></ol><p>Tebrikler! Artık Visual Studio kullanarak C# programları yazabilir ve çalıştırabilirsiniz. Visual Studio, hata ayıklama, sürüm kontrolü ve birçok gelişmiş özellik sunar. İlerledikçe, bu araçları kullanarak daha karmaşık C# projeleri geliştirebilir ve C# programlama becerilerinizi geliştirebilirsiniz. İyi kodlamalar!</p>

Visual Studio ile C# Kurulumu: Adım Adım Rehber

<p>C#, Microsoft tarafından geliştirilen, güçlü tip denetimine sahip, nesne yönelimli bir programlama dilidir. .NET Framework ve .NET Core sayesinde geniş bir uygulama yelpazesine sahip olan C#, web geliştirmeden masaüstü uygulamalarına, oyun geliştirmeden mobil uygulamalara kadar birçok alanda etkin bir şekilde kullanılmaktadır. Bu makalede, C# ile gerçekleştirebileceğiniz popüler uygulama türlerini ve bu dilin diğer programlama dilleriyle karşılaştırılmasını inceleyeceğiz.</p><h2>Web Geliştirme</h2><p>C#, <a target="" rel="noopener noreferrer nofollow" href="http://ASP.NET">ASP.NET</a> çatısı altında güçlü ve dinamik web uygulamaları ve API'ler geliştirmek için tercih edilen dillerden biridir. MVC (Model-View-Controller) mimarisi, Razor sayfa şablonları ve Blazor gibi teknolojilerle birlikte C#, web geliştiricilere hızlı ve güvenli uygulamalar oluşturma imkanı sunar.</p><h2>Veri Analizi ve Bilim</h2><p>C# ve .NET ekosistemi, veri analizi ve bilimsel hesaplamalar için de kullanılabilir. <a target="_blank" rel="noopener noreferrer nofollow" href="https://dotnet.microsoft.com">ML.NET</a> kütüphanesi, makine öğrenimi projeleri için C# geliştiricilerine özel araçlar sunar. Ancak, bu alanda Python'un sunduğu kütüphane çeşitliliği ve topluluk desteği nedeniyle daha yaygın kullanıldığını belirtmek gerekir.</p><h2>Makine Öğrenimi ve Yapay Zeka</h2><p>C#, <a target="_blank" rel="noopener noreferrer nofollow" href="https://dotnet.microsoft.com">ML.NET</a> kütüphanesi sayesinde makine öğrenimi ve yapay zeka projelerinde kullanılabilmektedir. Veri setlerini işleme, model eğitme ve tahmin yapma gibi işlemler bu kütüphane aracılığıyla gerçekleştirilebilir. C#, özellikle .NET ekosistemi içerisinde yapay zeka uygulamaları geliştirmek isteyenler için etkili çözümler sunar.</p><h2>Oyun Geliştirme</h2><p>C# ve Unity oyun motoru, oyun geliştiriciler arasında oldukça popülerdir. Unity, 2D ve 3D oyunlar, sanal gerçeklik (VR) ve artırılmış gerçeklik (AR) uygulamaları oluşturmak için geniş olanaklar sağlar. C#'ın Unity ile olan uyumu, oyun geliştirme sürecini kolaylaştırır ve güçlü oyun mekanikleri, görseller ve sesler üzerinde tam kontrol sunar.</p><h2>Masaüstü Uygulamalar</h2><p>C#, WPF (Windows Presentation Foundation), Windows Forms ve UWP (Universal Windows Platform) gibi teknolojilerle birlikte zengin masaüstü uygulamaları geliştirmek için kullanılır. Bu teknolojiler, kullanıcı arayüzü tasarımı ve uygulama mantığının kolayca entegre edilmesine olanak tanır.</p><h2>Mobil Uygulama Geliştirme</h2><p>Xamarin, C# kullanarak Android, iOS ve Windows için yerel mobil uygulamalar geliştirmeye imkan tanıyan bir platformdur. C#, Xamarin aracılığıyla, kod tekrarını en aza indirerek ve .NET ekosistemi içerisinde kalarak mobil uygulama geliştirme sürecini optimize eder.</p><h2>Gömülü Sistemler ve IoT</h2><p>C#, .NET Core ve .NET IoT kütüphaneleri sayesinde, Raspberry Pi gibi mikrodenetleyiciler üzerinde çalışabilen uygulamalar geliştirmek için de kullanılabilir. Bu, C#’ın gömülü sistemler ve İnternet Nesneleri projelerinde de etkili bir seçenek haline gelmesini sağlar.</p><h2>Sonuç</h2><p>C#, .NET ekosistemi içinde geniş bir uygulama alanına sahip, güçlü ve esnek bir programlama dilidir. Özellikle web ve masaüstü uygulama geliştirme, mobil uygulamalar ve oyun geliştirme gibi alanlarda önemli avantajlar sunar. Diğer programlama dillerine göre sağladığı güçlü tip denetimi, geniş kütüphane desteği ve Microsoft tarafından sağlanan sürekli güncellemeler ile geliştiricilere güvenilir bir geliştirme ortamı sunar. C# ile çalışmaya başlamak isteyenler için çevrimiçi kaynaklar ve topluluk destekli platformlar geniş bir bilgi havuzu sağlar.</p>

C# ile Yapabilecekleriniz: C#'ın Uygulama Alanları

<p>C# (C sharp), Microsoft tarafından geliştirilen, güçlü, nesne yönelimli bir programlama dilidir. .NET Framework üzerinde çalışır ve web, masaüstü, mobil ve oyun geliştirmek için kullanılabilir. C#'ın, Java, C++ gibi dillerle benzer yönleri bulunsa da, özellikle .NET ekosistemiyle entegrasyonu, dilin yapısal özellikleri ve kullanım kolaylığı açısından farklılıklar gösterir.</p><h2><strong>C#’ın Avantajları</strong></h2><ul><li><p><strong>Hızlı Geliştirme Süreci</strong>: C#, .NET kütüphanesinin sağladığı geniş araç seti sayesinde hızlı geliştirme süreçleri sunar.</p></li><li><p><strong>Güvenli Kod</strong>: Güçlü tip denetimi ve otomatik çöp toplama mekanizması, hataları azaltır ve güvenli kod yazmayı teşvik eder.</p></li><li><p><strong>Çok Yönlülük</strong>: C#, masaüstü uygulamaları, web siteleri, mobil uygulamalar ve hatta oyun geliştirme gibi çeşitli alanlarda kullanılabilir.</p></li><li><p><strong>Geniş Topluluk ve Destek</strong>: C# ve .NET’in geniş bir kullanıcı topluluğu ve Microsoft tarafından sağlanan kapsamlı dökümantasyonu vardır. Bu, öğrenme ve geliştirme sürecini kolaylaştırır.</p></li></ul><h2>C# ve Diğer Diller Arasındaki Farklar</h2><h3>Java ile Karşılaştırma</h3><ul><li><p><strong>Platform Bağımsızlık</strong>: Java, "Write Once, Run Anywhere" (Bir Kere Yaz, Her Yerde Çalıştır) felsefesiyle platformlar arası taşınabilirliğe büyük önem verirken, C# başlangıçta daha çok Windows platformuna odaklanmıştır. Ancak .NET Core'un gelişimiyle birlikte C# da platformlar arası uygulamalar geliştirmede kullanılmaya başlanmıştır.</p></li><li><p><strong>Dil Özellikleri</strong>: C# ve Java söz dizimi açısından birbirlerine oldukça benzerler, ancak C# daha modern dil özellikleri sunar. Örneğin, C# içerisinde LINQ, anonim türler, özellikler (properties), indeksleyiciler, delegeler gibi dil özellikleri bulunur.</p></li></ul><h3>C++ ile Karşılaştırma</h3><ul><li><p><strong>Bellek Yönetimi</strong>: C++ programcıdan belleği manuel olarak yönetmesini beklerken, C# otomatik çöp toplama (garbage collection) mekanizmasıyla bellek yönetimini kolaylaştırır.</p></li><li><p><strong>Güvenlik</strong>: C#, C++'a kıyasla daha güvenli bir programlama dilidir. C++'da sıkça karşılaşılan bellek taşması ve işaretçi hataları, C# dilinde daha sınırlıdır.</p></li><li><p><strong>Nesne Yönelimli Programlama (OOP)</strong>: Her iki dil de nesne yönelimli programlamayı destekler, ancak C# bu paradigmayı daha sıkı bir şekilde zorunlu kılar.</p></li></ul><h3>Python ile Karşılaştırma</h3><ul><li><p><strong>Performans</strong>: C# genellikle, derlenmiş bir dil olduğu için, yorumlanan Python diline göre daha iyi performans sunar.</p></li><li><p><strong>Söz Dizimi</strong>: Python, okunabilirliği ve basitliği ön planda tutan bir söz dizimine sahiptir. C#, güçlü tip denetimi ve açık sözdizimi ile daha katı bir dil yapısına sahiptir.</p></li><li><p><strong>Kullanım Alanları</strong>: Python, veri bilimi, makine öğrenmesi ve otomasyon gibi alanlarda yaygın olarak kullanılırken, C# .NET ekosistemiyle entegre çalışan uygulamalar ve oyun geliştirme (Unity ile) için tercih edilir.</p></li></ul><h3>JavaScript ile Karşılaştırma</h3><ul><li><p><strong>Çalışma Ortamı</strong>: JavaScript, başlangıçta yalnızca tarayıcılar içinde çalışacak şekilde tasarlanmış bir dilken, C# daha çok sunucu tarafı ve masaüstü uygulamaları için kullanılır.</p></li><li><p><strong>Tip Sistemi</strong>: JavaScript, zayıf tip denetimine sahip dinamik bir dildir. C# ise, güçlü tip denetimi sunan statik bir dildir.</p></li></ul><h2>Sonuç</h2><p>C#, Microsoft'un .NET ekosistemi için güçlü ve esnek bir dil olarak ortaya çıkmıştır. Modern programlama dilinin gerektirdiği özellikleri barındırır ve geniş bir kullanım alanına sahiptir. Diğer dillerle karşılaştırıldığında, C# kendi içinde benzersiz özellikler ve avantajlar sunar. Özellikle Windows platformu ve oyun geliştirme alanında tercih edilen bir dildir.</p>

C# Giriş: C# Nedir ve Diğer Programlama Dillerinden Farkları

<p>Node.js, event-driven yapısı ve asenkron çalışma mantığı ile yüksek performanslı ve ölçeklenebilir uygulamalar geliştirmeye olanak tanır. Bu yapı içerisinde, event loop ve çeşitli callback kuyrukları (queues) büyük bir öneme sahiptir. Bu makalede, Node.js'deki check queue'yu ve diğer ilgili kuyrukları detaylı bir şekilde inceleyeceğiz. Ayrıca, çeşitli örneklerle bu kavramları pekiştireceğiz.</p><h3>1. Event Loop ve Callback Kuyrukları</h3><p>Node.js'deki event loop, ana iş parçacığını bloklamadan çeşitli asenkron işlemleri yönetir. Event loop'un farklı fazları vardır ve her faz belirli türdeki callback'leri işler:</p><ul><li><p><strong>Senkron Kod</strong>: İlk olarak çalıştırılan kod parçasıdır. Bu kod doğrudan çalıştırılır ve bloklama potansiyeline sahiptir.</p></li><li><p><strong>Micro Task Queues</strong>: process.nextTick ve Promise.resolve gibi işlemlerle eklenen görevler bu kuyrukta yer alır. Mikro görevler, senkron koddan hemen sonra çalıştırılır ve yüksek önceliğe sahiptir.</p></li><li><p><strong>Timer Queue</strong>: setTimeout ve setInterval gibi zamanlayıcılarla eklenen geri çağırma fonksiyonları bu kuyrukta toplanır. Belirtilen gecikme süresi tamamlandığında bu kuyruktaki görevler çalıştırılır.</p></li><li><p><strong>I/O Queue</strong>: Dosya okuma/yazma, ağ işlemleri gibi I/O operasyonları tamamlandığında geri çağırma fonksiyonları bu kuyrukta yer alır ve zamanlayıcı kuyruğundan sonra çalıştırılır.</p></li><li><p><strong>I/O Polling</strong>: I/O olaylarını işler ve yeni gelen I/O olaylarını bekler.</p></li><li><p><strong>Check Kuyruğu</strong>: <code>setImmediate</code> callback'lerini işler.</p></li><li><p><strong>Close Kuyruğu</strong>: Kapatma işlemleriyle ilgili callback'leri işler, örneğin <code>socket.on('close', ...)</code>.</p></li></ul><h3>2. IO Polling ve Check Queue</h3><p>IO polling ve check queue, Node.js'deki asenkron işlemleri anlamak için kritik öneme sahiptir. IO polling, dosya okuma/yazma gibi I/O işlemlerinin tamamlanmasını bekler. Bu işlemler tamamlandığında, ilgili callback'ler IO queue'ya eklenir. Check queue ise <code>setImmediate</code> tarafından eklenen callback'leri işler.</p><p>Önceki videolarımızda, IO polling'in IO queue ve check queue arasında nasıl gerçekleştiğini anladık. Örneğin, <code>readFile</code> işlemi sonrasında <code>setImmediate</code>'in kilitlenme sırasını inceledik. Şimdi bu konuyu daha derinlemesine inceleyelim.</p><h3>3. Örnek 1: Callback Kuyruklarının Sıralaması</h3><p>Bu örnekte, çeşitli callback kuyruklarının nasıl çalıştığını gözlemleyeceğiz.</p><p><strong>Kod:</strong></p><pre><code>const fs = require('fs');

fs.readFile(__filename, (err, data) =&gt; {
    console.log('Read File Callback');
    setImmediate(()=&gt; {
      console.log("ReadFile içinde Set Immediate Callback");
    })
});

process.nextTick(() =&gt; {
    console.log('Next Tick Callback');
});

Promise.resolve().then(() =&gt; {
    console.log('Promise Callback');
});

setTimeout(() =&gt; {
    console.log('Set Timeout Callback');
}, 0);</code></pre><p>Bu kodda, <code>readFile</code>, <code>setImmediate</code>, <code>process.nextTick</code>, <code>Promise.resolve</code> ve <code>setTimeout</code> callback'lerinin çalışma sırasını inceleyeceğiz.</p><p><strong>Beklenen Çıktı:</strong></p><ul><li><p><code>Next Tick Callback</code></p></li><li><p><code>Promise Callback</code></p></li><li><p><code>Set Timeout Callback</code></p></li><li><p><code>Read File Callback</code></p></li><li><p><code>ReadFile içinde Set Immediate Callback</code></p></li></ul><p>Bu örnekten çıkarabileceğimiz önemli bir bilgi, micro task queue (process.nextTick ve Promise.resolve) callback'lerinin diğer tüm callback kuyruklarından önce çalıştığıdır.</p><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1706020585/bg-forum/vg1f2k651ezoql4irnjn.gif" alt="check queue image"><h3>4. Örnek 2: <code>readFile</code> İçinde <code>process.nextTick</code> ve <code>Promise.resolve</code></h3><p>Bu örnekte, <code>readFile</code> callback'i içinde <code>setImmediate</code>'den sonra <code>process.nextTick</code> ve <code>Promise.resolve</code> ekleyeceğiz.</p><p><strong>Kod:</strong></p><pre><code>const fs = require("fs");

fs.readFile(__filename, (err, data) =&gt; {
  console.log("Read File Callback");
  setImmediate(() =&gt; console.log("ReadFile içinde Set Immediate Callback"));
  process.nextTick(() =&gt; {
    console.log("ReadFile içinde Next Tick Callback");
  });

  Promise.resolve().then(() =&gt; {
    console.log("ReadFile içinde Promise Callback");
  });
});

process.nextTick(() =&gt; {
  console.log("Next Tick Callback");
});

Promise.resolve().then(() =&gt; {
  console.log("Promise Callback");
});

setTimeout(() =&gt; {
  console.log("Set Timeout Callback");
}, 0);</code></pre><p>Bu değişiklikle, <code>readFile</code> callback'i içinde eklenen <code>process.nextTick</code> ve <code>Promise.resolve</code> callback'lerinin nasıl çalıştığını gözlemleyeceğiz.</p><p><strong>Beklenen Çıktı:</strong></p><ul><li><p><code>Next Tick Callback</code></p></li><li><p><code>Promise Callback</code></p></li><li><p><code>Set Timeout Callback</code></p></li><li><p><code>Read File Callback</code></p></li><li><p><code>ReadFile içinde Next Tick Callback</code></p></li><li><p><code>ReadFile içinde Promise Callback</code></p></li><li><p><code>ReadFile içinde Set Immediate Callback</code></p></li></ul><p>Bu örnekten çıkarabileceğimiz bilgi, <code>readFile</code> içinde eklenen micro task queue callback'lerinin, diğer micro task queue callback'lerinden sonra çalıştığıdır.</p><h3>5. Örnek 3: Üç <code>setImmediate</code> Çağrısı ve <code>process.nextTick</code> ile <code>Promise.resolve</code></h3><p>Bu örnekte, üç <code>setImmediate</code> çağrısı yapacağız ve ikinci <code>setImmediate</code> içinde <code>process.nextTick</code> ve <code>Promise.resolve</code> ekleyeceğiz.</p><p><strong>Kod:</strong></p><pre><code>setImmediate(() =&gt; console.log("Set Immediate Callback 1"));

setImmediate(() =&gt; {
  console.log("Set Immediate Callback 2");
  process.nextTick(() =&gt; {
    console.log("Set Immediate 2 içinde Next Tick Callback");
  });

  Promise.resolve().then(() =&gt; {
    console.log("Set Immediate 2 içinde Promise Callback");
  });
});

setImmediate(() =&gt; console.log("Set Immediate Callback 3"));</code></pre><p>Bu kod ile, check queue callback'leri arasında micro task queue callback'lerinin çalıştığını gözlemleyeceğiz.</p><p><strong>Beklenen Çıktı:</strong></p><ul><li><p><code>Set Immediate Callback 1</code></p></li><li><p><code>Set Immediate Callback 2</code></p></li><li><p><code>Set Immediate 2 içinde Next Tick Callback</code></p></li><li><p><code>Set Immediate 2 içinde Promise Callback</code></p></li><li><p><code>Set Immediate Callback 3</code></p></li></ul><p>Bu örnek, micro task queue callback'lerinin check queue callback'lerinin arasında çalıştığını gösterir.</p><h3>6. Örnek 4: <code>setTimeout</code> ve <code>setImmediate</code> Anomalisi</h3><p>Bu örnekte, <code>setTimeout</code> (0ms gecikme ile) ve <code>setImmediate</code> çağrısı yapacağız.</p><p><strong>Kod:</strong></p><pre><code>setTimeout(() =&gt; console.log("Set Timeout Callback 1"), 0);
setImmediate(() =&gt; console.log("Set Immediate Callback 1"));</code></pre><p>Bu örnek, <code>setTimeout</code> ve <code>setImmediate</code> sırasının her zaman aynı olmadığını gösterir. IO queue ile ilgili önceki videoda açıklanan nedenlerden dolayı, bu işlemlerin sırası garanti edilemez.</p><p><strong>Beklenen Çıktı:</strong> Çalıştırıldığında, çıktı değişebilir:</p><ul><li><p><code>Set Timeout Callback 1</code></p></li><li><p><code>Set Immediate Callback 1</code> veya</p></li><li><p><code>Set Immediate Callback 1</code></p></li><li><p><code>Set Timeout Callback 1</code></p></li></ul><p>Uzun süreli bir <code>for</code> döngüsü eklenirse, <code>setTimeout</code> her zaman <code>setImmediate</code>'den önce çalışır.</p><h4>Sonuç</h4><p>Bu makalede, Node.js'deki check queue ve ilgili diğer kuyrukların nasıl çalıştığını detaylı bir şekilde inceledik. Yapılan örnekler, bu kavramları anlamamıza yardımcı oldu ve Node.js'nin asenkron çalışma mantığını pekiştirdi. Check queue, event loop ve micro task queue gibi kavramlar, Node.js ile performanslı ve ölçeklenebilir uygulamalar geliştirmek için kritik öneme sahiptir.</p>

Node.js'de Check Queue

<p>Node.js, asenkron ve olay güdümlü yapısıyla yüksek performanslı ve ölçeklenebilir uygulamalar geliştirmek için ideal bir platformdur. Node.js'in temelinde, olay döngüsü (event loop) adı verilen bir mekanizma bulunur. Bu mekanizma, non-blocking I/O operasyonlarını yönetir ve farklı kuyruklar aracılığıyla görevlerin yürütülmesini sağlar. Bu makalede, Node.js'deki I/O polling (I/O anketleme) ve check kuyruğunun nasıl çalıştığını ayrıntılı olarak inceleyeceğiz.</p><h3>Olay Döngüsü ve Kuyruklar</h3><p>Node.js olay döngüsü, görevleri farklı kuyruklara yerleştirir ve bu kuyrukları belirli bir sırayla işler. Temel kuyruklar şunlardır:</p><ul><li><p><strong>Micro Task Kuyruğu</strong>: <code>process.nextTick</code> ve <code>Promise</code> callback'lerini içerir.</p></li><li><p><strong>Timer Kuyruğu</strong>: <code>setTimeout</code> ve <code>setInterval</code> gibi zamanlayıcı tabanlı callback'leri içerir.</p></li><li><p><strong>I/O Kuyruğu</strong>: Tamamlanmış I/O operasyonları için callback'leri içerir.</p></li><li><p><strong>Check Kuyruğu</strong>: <code>setImmediate</code> callback'lerini içerir.</p></li></ul><p>Bu kuyruklar, belirli bir sırayla işlenir ve her kuyruk, olay döngüsünün farklı bir aşamasında çalıştırılır.</p><h3>I/O Polling</h3><p>I/O polling, Node.js'in I/O operasyonlarını nasıl yönettiğini anlamak için kritik bir kavramdır. Olay döngüsü, I/O kuyruğuna ulaştığında, tamamlanmış I/O operasyonları için callback'leri kuyruğa eklemek üzere polling yapar. Polling işlemi, I/O işlemlerinin tamamlanıp tamamlanmadığını kontrol eder ve tamamlanmış işlemler için callback'leri kuyruğa ekler.</p><h3><strong>I/O Polling Süreci</strong></h3><ol><li><p><strong>I/O İşlemleri Başlatılır:</strong> Node.js uygulamasında, <code>fs.readFile</code>, <code>http.get</code> gibi asenkron I/O fonksiyonları çağrıldığında, bu işlemler işletim sistemi düzeyindeki non-blocking I/O API'lerine iletilir.</p></li><li><p><strong>Event Loop ve I/O Polling Fazı:</strong> Event Loop, I/O polling fazına ulaştığında, tamamlanan I/O işlemlerini kontrol eder. Tamamlanan işlemler için callback'ler, I/O Queue'ya eklenir.</p></li><li><p><strong>Callback'lerin İşlenmesi:</strong> Event Loop, I/O Queue'daki callback'leri sırayla işler. Bu, uygulamanın diğer asenkron işlemlere devam edebilmesi için önemlidir çünkü I/O işlemleri genellikle zaman alıcıdır.</p></li></ol><h3><strong>I/O Polling'in Avantajları</strong></h3><ul><li><p><strong>Non-blocking Davranış:</strong> Uygulamanın I/O işlemleri tamamlanana kadar bloke olmamasını sağlar.</p></li><li><p><strong>Etkin Kaynak Kullanımı:</strong> I/O işlemleri beklerken, Node.js diğer asenkron görevleri işleyebilir.</p></li><li><p><strong>Esneklik:</strong> Çeşitli türdeki I/O işlemlerini (dosya sistemi, ağ, veritabanı) tek bir model altında yönetir.</p></li></ul><p>Bu süreci daha iyi anlamak için bir örnek inceleyelim:</p><pre><code>const fs = require('fs');

process.nextTick(() =&gt; {
  console.log('nextTick');
});

Promise.resolve().then(() =&gt; {
  console.log('Promise');
});

setTimeout(() =&gt; {
  console.log('setTimeout');
}, 0);

fs.readFile(__filename, (err, data) =&gt; {
  console.log('readFile');
});

setImmediate(() =&gt; {
  console.log('setImmediate');
});</code></pre><p>Yukarıdaki kodda, çeşitli asenkron işlemler gerçekleştirilmiştir: <code>nextTick</code>, <code>Promise</code>, <code>setTimeout</code>, <code>readFile</code> ve <code>setImmediate</code>. Bu işlemlerin nasıl sıralandığını inceleyelim:</p><ol><li><p><strong>Micro Task Kuyruğu</strong>: <code>process.nextTick</code> ve <code>Promise</code> callback'leri önce işlenir.</p></li><li><p><strong>Timer Kuyruğu</strong>: <code>setTimeout</code> callback'i işlenir.</p></li><li><p><strong>I/O Kuyruğu</strong>: <code>readFile</code> callback'i işlenir.</p></li><li><p><strong>Check Kuyruğu</strong>: <code>setImmediate</code> callback'i işlenir.</p></li></ol><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1706016190/bg-forum/p54ybtmlis85figq2ys6.gif" alt="i/o polling image"><h3>Olay Döngüsünün Çalışma Süreci</h3><ol><li><p><strong>Micro Task Kuyruğu</strong>:</p><ul><li><p>İlk olarak, <code>process.nextTick</code> callback'i yürütülür ve <code>nextTick</code> konsola yazdırılır.</p></li><li><p>Daha sonra, <code>Promise</code> callback'i yürütülür ve <code>Promise</code> konsola yazdırılır.</p></li></ul></li><li><p><strong>Timer Kuyruğu</strong>:</p><ul><li><p><code>setTimeout</code> callback'i yürütülür ve <code>setTimeout</code> konsola yazdırılır.</p></li></ul></li><li><p><strong>I/O Kuyruğu</strong>:</p><ul><li><p>Olay döngüsü I/O kuyruğuna ulaştığında, <code>readFile</code> callback'inin hazır olmaması nedeniyle kontrol polling kısmına geçer.</p></li><li><p>Polling işlemi, <code>readFile</code> tamamlandığında callback'i kuyruğa ekler.</p></li><li><p>Ancak, yürütme I/O kuyruğunu geçtiği için callback beklemek zorunda kalır.</p></li></ul></li><li><p><strong>Check Kuyruğu</strong>:</p><ul><li><p><code>setImmediate</code> callback'i yürütülür ve <code>setImmediate</code> konsola yazdırılır.</p></li></ul></li><li><p><strong>Yeni İterasyon</strong>:</p><ul><li><p>Yeni bir iterasyon başladığında, I/O kuyruğundaki <code>readFile</code> callback'i yürütülür ve <code>readFile</code> konsola yazdırılır.</p></li></ul></li></ol><h3>I/O Polling'in Önemi</h3><p>I/O polling, Node.js'in yüksek performanslı ve non-blocking I/O işlemlerini yönetmesini sağlar. Olay döngüsü, I/O işlemlerini sürekli kontrol ederek tamamlanmış işlemler için callback'leri kuyruğa ekler ve bu sayede diğer görevlerin yürütülmesini engellemez. Bu mekanizma, Node.js'in aynı anda birçok I/O işlemi gerçekleştirebilmesini ve bu işlemler arasında verimli bir şekilde geçiş yapabilmesini sağlar.</p><h3>Check Kuyruğu ve setImmediate</h3><p>Check kuyruğu, olay döngüsünün check aşamasında yürütülen callback'leri içerir. <code>setImmediate</code> fonksiyonu, bu kuyruğa bir callback eklemek için kullanılır. <code>setImmediate</code>, mevcut I/O operasyonları tamamlandıktan hemen sonra yürütülmek üzere bir callback ekler. Bu, zamanlamanın kritik olduğu durumlarda kullanışlıdır ve genellikle <code>process.nextTick</code> ile karşılaştırılır.</p><p><code>setImmediate</code> ve <code>process.nextTick</code> arasındaki farklar:</p><ul><li><p><code>process.nextTick</code>: Bu fonksiyon, mevcut operasyon tamamlandıktan hemen sonra çalıştırılacak bir callback ekler. Micro task kuyruğunda yer alır ve <code>Promise</code> callback'leriyle birlikte işlenir.</p></li><li><p><code>setImmediate</code>: Bu fonksiyon, olay döngüsünün check aşamasında çalıştırılacak bir callback ekler. Check kuyruğunda yer alır ve I/O operasyonları tamamlandıktan sonra işlenir.</p></li></ul><h3>Sonuç</h3><p>Node.js'deki I/O polling ve check kuyruğu, olay döngüsünün verimli çalışmasını sağlayan kritik bileşenlerdir. I/O polling, tamamlanmış I/O işlemlerini sürekli kontrol ederken, check kuyruğu <code>setImmediate</code> gibi callback'leri işlemek için kullanılır. Bu mekanizmalar, Node.js'in asenkron yapısını destekler ve yüksek performanslı uygulamalar geliştirilmesine olanak tanır. Node.js'de I/O polling ve check kuyruğunu anlamak, geliştiricilere daha verimli ve ölçeklenebilir uygulamalar oluşturma konusunda büyük avantaj sağlar.</p>

Node.js'de I/O Polling

<p>Node.js, asenkron yapısıyla bilinen ve olay güdümlü (event-driven) bir çalışma modeline sahip olan popüler bir JavaScript çalışma ortamıdır. Bu yapının merkezinde ise event loop (olay döngüsü) bulunur. Event loop, çeşitli kuyruklardan gelen görevleri belirli bir sıraya göre işleyerek Node.js'in yüksek performanslı ve ölçeklenebilir olmasını sağlar. Bu makalede, Node.js'teki I/O queue (giriş/çıkış kuyruğu) ve diğer önemli kuyruklar hakkında detaylı bir inceleme yapacağız.</p><h4>1. Event Loop ve Kuyruklar</h4><p>Node.js'in etkin ve hızlı çalışmasının arkasındaki anahtar bileşen event loop'tur. Event loop, senkron ve asenkron işlemlerin işlenme sırasını düzenleyen bir döngüdür. Bu döngüde çeşitli kuyruklar bulunur ve her kuyruğun farklı bir önceliği vardır:</p><ul><li><p><strong>Senkron Kod</strong>: İlk olarak çalıştırılan kod parçasıdır. Bu kod doğrudan çalıştırılır ve bloklama potansiyeline sahiptir.</p></li><li><p><strong>Mikro Görev Kuyrukları (Micro Task Queues)</strong>: process.nextTick ve Promise.resolve gibi işlemlerle eklenen görevler bu kuyrukta yer alır. Mikro görevler, senkron koddan hemen sonra çalıştırılır ve yüksek önceliğe sahiptir.</p></li><li><p><strong>Zamanlayıcı Kuyruğu (Timer Queue)</strong>: setTimeout ve setInterval gibi zamanlayıcılarla eklenen geri çağırma fonksiyonları bu kuyrukta toplanır. Belirtilen gecikme süresi tamamlandığında bu kuyruktaki görevler çalıştırılır.</p></li><li><p><strong>I/O Kuyruğu (I/O Queue)</strong>: Dosya okuma/yazma, ağ işlemleri gibi I/O operasyonları tamamlandığında geri çağırma fonksiyonları bu kuyrukta yer alır ve zamanlayıcı kuyruğundan sonra çalıştırılır.</p></li></ul><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705956546/bg-forum/kepnljit7mes8smyx5k2.gif" alt="i/o queue image 3"><h4>2. I/O Queue Nedir?</h4><p>I/O queue, asenkron giriş/çıkış işlemleri tamamlandığında çalıştırılacak geri çağırma fonksiyonlarını barındıran bir kuyruktur. Node.js'te birçok asenkron fonksiyon, I/O queue'ya geri çağırma fonksiyonları ekler. Örneğin, fs modülünden readFile fonksiyonu kullanıldığında, dosya okuma işlemi tamamlandığında geri çağırma fonksiyonu I/O queue'ya eklenir.</p><h4>3. I/O Queue ve Diğer Kuyruklar Arasındaki İlişki</h4><p>Node.js'teki kuyruklar arasında belirli bir öncelik sırası vardır. Bu öncelik sırası, görevlerin ne zaman çalıştırılacağını belirler ve uygulamanın performansını optimize eder.</p><h5><strong>Örnek Senaryo:</strong></h5><p>Bir Node.js uygulamasında aşağıdaki kod parçacığını ele alalım:</p><pre><code>const fs = require('fs');

fs.readFile(__filename, (err, data) =&gt; {
    console.log('Read File Callback');
});

process.nextTick(() =&gt; {
    console.log('Next Tick Callback');
});

Promise.resolve().then(() =&gt; {
    console.log('Promise Callback');
});

setTimeout(() =&gt; {
    console.log('Set Timeout Callback');
}, 0);</code></pre><p>Bu kodda, dört asenkron işlem bulunmaktadır:</p><ol><li><p><strong>fs.readFile</strong>: Dosya okuma işlemi tamamlandığında I/O queue'ya geri çağırma ekler.</p></li><li><p><strong>process.nextTick</strong>: Mikro görev kuyruğuna geri çağırma ekler.</p></li><li><p><strong>Promise.resolve</strong>: Mikro görev kuyruğuna geri çağırma ekler.</p></li><li><p><strong>setTimeout</strong>: Zamanlayıcı kuyruğuna geri çağırma ekler.</p></li></ol><p>Bu işlemler event loop'ta aşağıdaki sıraya göre çalıştırılacaktır:</p><ol><li><p>İlk olarak senkron kod çalıştırılır.</p></li><li><p>Mikro görev kuyruğundaki geri çağırmalar çalıştırılır (process.nextTick ve Promise.resolve).</p></li><li><p>Zamanlayıcı kuyruğundaki geri çağırmalar çalıştırılır (setTimeout).</p></li><li><p>Son olarak, I/O queue'daki geri çağırmalar çalıştırılır (fs.readFile).</p></li></ol><p>Çıktı şu şekilde olacaktır:</p><pre><code>Next Tick Callback
Promise Callback
Set Timeout Callback
Read File Callback</code></pre><h4>4. Zamanlayıcı ve I/O Kuyruğu Arasındaki Belirsizlik</h4><p>Node.js'te zamanlayıcı ve I/O kuyrukları arasındaki öncelik bazen tutarsız olabilir. Bu tutarsızlık, zamanlayıcıların minimum gecikme süresinin 1 milisaniye olarak ayarlanmasından kaynaklanır. Örneğin, setTimeout ile 0 milisaniye gecikme ayarlansa bile, bu gecikme süresi 1 milisaniyeye ayarlanır. Bu durum, zamanlayıcı geri çağırmasının I/O geri çağırmasından önce veya sonra çalışmasına neden olabilir.</p><h5>Örnek:</h5><pre><code>const fs = require('fs');

fs.readFile(__filename, (err, data) =&gt; {
    console.log('Read File Callback');
});

setTimeout(() =&gt; {
    console.log('Set Timeout Callback');
}, 0);</code></pre><p>Bu kodda, çıktının her çalıştırmada farklı olabileceği gözlemlenebilir:</p><pre><code>Read File Callback
Set Timeout Callback</code></pre><p>veya</p><pre><code>Set Timeout Callback
Read File Callback</code></pre><p>Bu belirsizlik, zamanlayıcı kuyruğunun minimum gecikme süresinden kaynaklanır ve CPU'nun ne kadar meşgul olduğuna bağlı olarak değişebilir.</p><h4>5. I/O Queue'nun Önceliği</h4><p>I/O queue, event loop'ta zamanlayıcı kuyruğundan sonra çalıştırılır. Bu, asenkron I/O işlemlerinin zamanlayıcılardan sonra işlendiği anlamına gelir. Mikro görev kuyruğu ve zamanlayıcı kuyruğu boşaldıktan sonra I/O queue'daki görevler çalıştırılır.</p><p>Örnek:</p><pre><code>const fs = require('fs');

fs.readFile(__filename, (err, data) =&gt; {
    console.log('Read File Callback');
});

process.nextTick(() =&gt; {
    console.log('Next Tick Callback');
});

Promise.resolve().then(() =&gt; {
    console.log('Promise Callback');
});

setTimeout(() =&gt; {
    console.log('Set Timeout Callback');
}, 0);</code></pre><p>Bu kodda, event loop aşağıdaki sırayla çalışacaktır:</p><ol><li><p><strong>Next Tick Callback</strong></p></li><li><p><strong>Promise Callback</strong></p></li><li><p><strong>Set Timeout Callback</strong></p></li><li><p><strong>Read File Callback</strong></p></li></ol><p>Çıktı sırası:</p><pre><code>Next Tick Callback
Promise Callback
Set Timeout Callback
Read File Callback</code></pre><h4>Sonuç</h4><p>Node.js'in event loop mekanizması ve çeşitli kuyrukların işleyişi, yüksek performanslı ve ölçeklenebilir uygulamalar geliştirmeyi mümkün kılar. I/O queue, asenkron I/O işlemlerinin işlenmesini sağlar ve mikro görevler ile zamanlayıcı görevlerinden sonra çalıştırılır. Bu öncelik sırası, uygulamanın etkinliğini artırır ve görevlerin doğru zamanda işlenmesini sağlar. Node.js'in asenkron yapısını ve event loop'un işleyişini anlamak, geliştiricilere daha verimli ve etkili kod yazma becerisi kazandırır.</p>

Node.js'de I/O Queue

<p>Node.js, yüksek performans ve ölçeklenebilirlik sunan, olay güdümlü bir asenkron çalışma modeline sahip bir JavaScript çalışma zamanıdır. Asenkron çalışma modeli, Node.js'in yüksek trafik altında bile hızlı ve verimli çalışmasını sağlar. Bu makalede, Node.js'in asenkron yapısını ve bu yapıdaki önemli bir kavram olan <strong>Timer Queue</strong>'yu detaylı bir şekilde inceleyeceğiz.</p><h3>1. Node.js Asenkron Yapısına Giriş</h3><p>Node.js, tek bir olay döngüsü (event loop) üzerinden çalışır. Bu, birden fazla işlemin aynı anda yürütülmesini sağlar ve yüksek performans sunar. Olay döngüsü, sıraya alınmış işlemleri (callback fonksiyonları) belirli bir sıra ve öncelik dahilinde yürütür. Bu sıranın anlaşılması, Node.js'de verimli asenkron kod yazmanın temelidir.</p><p>Asenkron yapının önemli bileşenleri şunlardır:</p><ul><li><p><strong>Call Stack (Çağrı Yığını)</strong></p></li><li><p><strong>Event Loop (Olay Döngüsü)</strong></p></li><li><p><strong>Callback Queue (Geri Çağırma Kuyruğu)</strong></p></li><li><p><strong>Microtask Queue (Mikro Görev Kuyruğu)</strong></p></li><li><p><strong>Timer Queue (Zamanlayıcı Kuyruğu)</strong></p></li><li><p><strong>I/O Queue (Giriş/Çıkış Kuyruğu)</strong></p></li></ul><h3>2. Timer Queue Nedir?</h3><p><strong>Timer Queue</strong>, belirli bir süre sonra yürütülmesi gereken callback fonksiyonlarını barındıran bir veri yapısıdır. Timer Queue'ya callback fonksiyonları eklemek için <code>setTimeout</code> veya <code>setInterval</code> fonksiyonları kullanılır. Bu kuyruk, diğer microtask kuyruklarına göre daha düşük bir önceliğe sahiptir.</p><p><strong>setTimeout</strong> ve <strong>setInterval</strong> fonksiyonlarının sözdizimi şu şekildedir:</p><pre><code>setTimeout(callbackFunction, delay);
setInterval(callbackFunction, delay);</code></pre><ul><li><p><code>callbackFunction</code>: Gecikme süresi sona erdiğinde yürütülecek fonksiyon.</p></li><li><p><code>delay</code>: Milisaniye cinsinden gecikme süresi.</p></li></ul><h3>3. Timer Queue ile Örnekler</h3><p>Bu bölümde, Timer Queue'nun nasıl çalıştığını ve öncelik sırasını anlamak için birkaç örnek yapacağız.</p><h5><strong>Örnek 1: Basit setTimeout Kullanımı ve Microtask Kuyrukları ile Karşılaştırma</strong></h5><p>İlk örneğimizde, <code>setTimeout</code>, <code>process.nextTick</code> ve <code>Promise.resolve</code> kullanarak farklı kuyrukların öncelik sırasını test edeceğiz.</p><pre><code>setTimeout(() =&gt; console.log("setTimeout 1"), 0);
setTimeout(() =&gt; console.log("setTimeout 2"), 0);
setTimeout(() =&gt; console.log("setTimeout 3"), 0);

process.nextTick(() =&gt; console.log("process.nextTick 1"));
process.nextTick(() =&gt; {
    console.log("process.nextTick 2");
    process.nextTick(() =&gt;
        console.log("next tick içinde iç next tick")
    );
});
process.nextTick(() =&gt; console.log("process.nextTick 3"));

Promise.resolve().then(() =&gt; console.log("Promise.resolve 1"));
Promise.resolve().then(() =&gt; {
    console.log("Promise.resolve 2");
    process.nextTick(() =&gt;
        console.log("Promise then bloğu içinde iç next tick")
    );
});
Promise.resolve().then(() =&gt; console.log("Promise.resolve 3"));</code></pre><p>Bu kodu çalıştırdığımızda, beklediğimiz çıktı:</p><pre><code>process.nextTick 1
process.nextTick 2
next tick içinde iç next tick
process.nextTick 3
Promise.resolve 1
Promise.resolve 2
Promise.resolve 3
Promise then bloğu içinde iç next tick
setTimeout 1
setTimeout 2
setTimeout 3</code></pre><p>Bu örnek, <code>process.nextTick</code> ve Promise çözümlemelerinin, timer queue'daki <code>setTimeout</code> fonksiyonlarından önce yürütüldüğünü gösterir.</p><h5><strong>Örnek 2: İç İçe Callback Fonksiyonları</strong></h5><p>İkinci örnekte, <code>setTimeout</code> fonksiyonu içinde <code>process.nextTick</code> kullanacağız.</p><pre><code>setTimeout(() =&gt; console.log("setTimeout 1"), 0);
setTimeout(() =&gt; {
    console.log("setTimeout 2");
    process.nextTick(() =&gt;
        console.log("setTimeout içinde iç next tick")
    );
}, 0);
setTimeout(() =&gt; console.log("setTimeout 3"), 0);

process.nextTick(() =&gt; console.log("process.nextTick 1"));
process.nextTick(() =&gt; {
    console.log("process.nextTick 2");
    process.nextTick(() =&gt;
        console.log("next tick içinde iç next tick")
    );
});
process.nextTick(() =&gt; console.log("process.nextTick 3"));

Promise.resolve().then(() =&gt; console.log("Promise.resolve 1"));
Promise.resolve().then(() =&gt; {
    console.log("Promise.resolve 2");
    process.nextTick(() =&gt;
        console.log("Promise then bloğu içinde iç next tick")
    );
});
Promise.resolve().then(() =&gt; console.log("Promise.resolve 3"));</code></pre><p>Bu kodu çalıştırdığımızda, beklediğimiz çıktı:</p><pre><code>process.nextTick 1
process.nextTick 2
next tick içinde iç next tick
process.nextTick 3
Promise.resolve 1
Promise.resolve 2
Promise.resolve 3
Promise then bloğu içinde iç next tick
setTimeout 1
setTimeout 2
setTimeout içinde iç next tick
setTimeout 3</code></pre><p>Bu örnek, <code>setTimeout</code> içinde <code>process.nextTick</code> kullanıldığında, <code>nextTick</code> fonksiyonunun timer queue'daki diğer callback fonksiyonlarından önce yürütüldüğünü gösterir.</p><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705788864/bg-forum/furrdcvxclmmtitk004a.gif" alt="timer queue image"><h5><strong>Örnek 3: Farklı Gecikme Süreleri ile setTimeout</strong></h5><p>Son örnekte, farklı gecikme sürelerine sahip <code>setTimeout</code> fonksiyonlarını kullanacağız.</p><pre><code>setTimeout(() =&gt; console.log("setTimeout 1"), 1000);
setTimeout(() =&gt; console.log("setTimeout 2"), 500);
setTimeout(() =&gt; console.log("setTimeout 3"), 0);</code></pre><p>Bu kodu çalıştırdığımızda, beklediğimiz çıktı:</p><pre><code>setTimeout 3
setTimeout 2
setTimeout 1</code></pre><p>Bu örnek, en kısa gecikme süresine sahip <code>setTimeout</code> fonksiyonunun önce yürütüldüğünü gösterir.</p><h4>4. Timer Queue'nun FIFO Sırası</h4><p>Timer Queue, aslında bir Min Heap veri yapısıdır. Ancak, anlamayı kolaylaştırmak için FIFO (First In, First Out) sırasıyla çalıştığını düşünebiliriz. Bu, en kısa gecikme süresine sahip callback fonksiyonlarının önce sıraya alınmasını ve yürütülmesini sağlar.</p><h4>Sonuç</h4><p>Bu makalede, Node.js'in asenkron yapısını ve Timer Queue'nun nasıl çalıştığını detaylı bir şekilde inceledik. Timer Queue, Node.js'in olay güdümlü asenkron çalışma modelinde önemli bir rol oynar ve doğru anlaşıldığında asenkron kod yazmayı daha etkili hale getirir. Timer Queue'nun mikro görev kuyruklarından daha düşük önceliğe sahip olduğunu ve FIFO sırasına göre çalıştığını öğrendik. Bu bilgiler, Node.js uygulamalarında daha verimli ve öngörülebilir asenkron işlemler gerçekleştirmek için kritik öneme sahiptir.</p>

Node.js'de Timer Queue

<p>Node.js, asenkron yapısıyla bilinen ve büyük ölçekli uygulamalarda verimlilik sağlayan popüler bir JavaScript çalışma zamanı ortamıdır. Bu yazıda, Node.js'in mikro görev kuyrukları ve bunların çalışma sırasını detaylı bir şekilde inceleyeceğiz. Mikro görev kuyruklarının nasıl çalıştığını anlamak, Node.js uygulamalarının performansını optimize etmek için kritik öneme sahiptir.</p><h4><strong>Node.js Event Loop Yapısı:</strong></h4><p>Node.js event loop, farklı türde görevlerin yürütüldüğü altı ana kuyruktan oluşur:</p><ol><li><p><strong>Next Queue:</strong> process.nextTick tarafından oluşturulan görevlerin saklandığı kuyruk.</p></li><li><p><strong>Promise Queue:</strong> Promise.resolve().then ile oluşturulan görevlerin saklandığı kuyruk.</p></li><li><p><strong>Timer Queue:</strong> setTimeout ve setInterval gibi zamanlayıcı fonksiyonları tarafından oluşturulan görevlerin saklandığı kuyruk.</p></li><li><p><strong>Input-Output (I/O) Queue:</strong> I/O işlemleri için kullanılan kuyruk.</p></li><li><p><strong>Check Queue:</strong> setImmediate tarafından oluşturulan görevlerin saklandığı kuyruk.</p></li><li><p><strong>Close Queue:</strong> close event'lerinin işlenmesi için kullanılan kuyruk.</p></li></ol><p>Bu kuyruklar, event loop içerisinde belirli bir sırayla işlenir ve her biri farklı türde görevleri işler.</p><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705744499/bg-forum/zfnkm4kae7puajlh72zg.webp" alt="Visualizing the event loop"><p><strong>Mikro Görev Kuyrukları:</strong></p><p>Mikro görev kuyrukları, next queue ve promise queue olarak ikiye ayrılır. Bu kuyruklar, event loop'un belirli aşamalarında öncelikli olarak işlenir. Mikro görev kuyrukları, özellikle yüksek öncelikli küçük görevlerin hızlı bir şekilde işlenmesi için kullanılır.</p><p><strong>Process.nextTick ve Promise.resolve:</strong></p><ul><li><p><strong>process.nextTick:</strong> Bu yöntem, bir callback fonksiyonunu next tick kuyruğuna ekler. <code>process.nextTick</code>, event loop'un bir sonraki aşamasına geçmeden önce çalıştırılacak küçük görevleri tanımlamak için kullanılır.</p><ul><li><p>Kullanımı: <code>process.nextTick(callbackFonksiyonu)</code></p></li></ul></li><li><p><strong>Promise.resolve().then:</strong> Bu yöntem, bir callback fonksiyonunu promise kuyruğuna ekler. Promise.resolve().then, Promise'ların tamamlanmasının ardından çalıştırılacak görevleri tanımlar.</p><ul><li><p>Kullanımı: <code>Promise.resolve().then(callbackFonksiyonu)</code></p></li></ul></li></ul><p><strong>Örnekler ve Çıkarımlar:</strong></p><ol><li><p><strong>İlk Örnek:</strong></p><p>İlk örnekte, iki <code>console.log</code> ifadesi ve aralarına bir <code>process.nextTick</code> ifadesi eklenir. Kod şu şekildedir:</p><pre><code>console.log(1);
process.nextTick(() =&gt; {
  console.log('This is process.nextTick callback');
});
console.log(2);</code></pre><p><strong>Sonuç:</strong> İlk olarak senkron <code>console.log</code> ifadeleri çalıştırılır ve ardından <code>process.nextTick</code> içindeki callback fonksiyonu çalıştırılır. Bu durum, senkron JavaScript kodunun, asenkron koddan önce çalıştığını gösterir. Yani, <code>process.nextTick</code> fonksiyonu, çağrı yığını tamamen boşaldıktan sonra çalışır.</p></li><li><p>İkinci Örnek:</p><p>İkinci örnekte, <code>process.nextTick</code> ve <code>Promise.resolve().then</code> ifadeleri birlikte kullanılır:</p><pre><code>Promise.resolve().then(() =&gt; {
  console.log('This is Promise.resolve callback');
});
process.nextTick(() =&gt; {
  console.log('This is process.nextTick callback');
});</code></pre><p><strong>Sonuç:</strong> <code>process.nextTick</code> içindeki callback fonksiyonları, promise kuyruğundakilerden önce çalışır. Yani, next tick kuyruğundaki tüm callback'ler, promise kuyruğundakilerden önceliklidir.</p></li><li><p>Gelişmiş Örnek:</p><p>İç içe <code>process.nextTick</code> ve <code>Promise.resolve().then</code> ifadeleri kullanılarak daha karmaşık bir yapı oluşturulur. Kod şu şekildedir:</p><pre><code>process.nextTick(() =&gt; console.log("process.nextTick 1"));
process.nextTick(() =&gt; {
    console.log("process.nextTick 2");
    process.nextTick(() =&gt;
        console.log("next tick içinde iç next tick")
    );
});

process.nextTick(() =&gt; console.log("process.nextTick 3"));
Promise.resolve().then(() =&gt; console.log("Promise.resolve 1"));
Promise.resolve().then(() =&gt; {
    console.log("Promise.resolve 2");
    process.nextTick(() =&gt;
        console.log("Promise then bloğu içinde iç next tick")
    );
});
Promise.resolve().then(() =&gt; console.log("Promise.resolve 3"));</code></pre><p><strong>Sonuç:</strong> İlk olarak, <code>process.nextTick</code> içindeki callback fonksiyonları çalıştırılır. İç içe olan <code>process.nextTick</code> fonksiyonları, dıştakiler tamamlanana kadar çalıştırılmaz. Sonrasında, <code>Promise.resolve().then</code> içindeki callback fonksiyonları çalıştırılır. Bu durum, next tick kuyruğunun promise kuyruğuna göre öncelikli olduğunu bir kez daha doğrular.</p><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705755064/bg-forum/wuaa1lfopgmlcjq0xzzq.gif" alt="microtask queue"></li></ol><p><strong>Önemli Notlar:</strong></p><p><code>process.nextTick</code>'in aşırı kullanımı, event loop’un diğer bölümlerinin çalışmasını engelleyebilir. Bu, I/O kuyruğunun çalışmasını engelleyerek performans sorunlarına yol açabilir. <code>process.nextTick</code>, iki ana amaç için kullanılmalıdır:</p><ol><li><p>Kullanıcıların hataları işlemesine, gereksiz kaynakları temizlemesine veya isteği yeniden denemesine izin vermek.</p></li><li><p>Çağrı yığını çözüldükten ancak event loop devam etmeden önce bir callback çalıştırmak.</p></li></ol><p><strong>Sonuç:</strong></p><p>Node.js'te mikro görev kuyrukları ve bunların çalışma sırasını anlamak, performansı optimize etmek ve daha verimli asenkron kod yazmak için kritik öneme sahiptir. <code>process.nextTick</code> ve <code>Promise.resolve().then</code> gibi yöntemlerin nasıl çalıştığını ve event loop içerisinde nasıl önceliklendirildiklerini bilmek, geliştiricilerin daha etkili Node.js uygulamaları yazmalarına yardımcı olur. Bu bilgiler, Node.js'in asenkron doğasını daha iyi kavramak ve uygulamalarınızda daha verimli çözümler üretmek için temel oluşturur.</p>

Node.js'de Microtask Queues ve Çalışma Sırası

<p>Node.js, JavaScript'in asenkron programlama yeteneklerini kullanarak yüksek performanslı ve ölçeklenebilir uygulamalar geliştirmek için popüler bir platformdur. Bu makalede, Node.js'in çekirdeğinde yer alan üç önemli bileşeni ve bunların birbirleriyle nasıl etkileşimde bulunduklarını inceleyeceğiz: Event Loop, Thread Pool ve İşletim Sistemi. Bu bileşenler birlikte çalışarak asenkron işlemleri koordine eder ve uygulamaların verimli bir şekilde çalışmasını sağlar.</p><h4>libuv ve Asenkron İşlemler</h4><p>Sağ tarafta libuv bulunur. Asenkron bir metod çalıştırdığınızda, bu işlem libuv'a devredilir. libuv, görevi işletim sisteminin yerel asenkron mekanizmalarını kullanarak veya mümkün değilse iş parçacığı havuzunu kullanarak çalıştırır. Böylece ana iş parçacığı engellenmez.</p><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1718832357/bg-forum/z3uhihqyjobwdcfdfadr.gif" alt="event loop"><h3>Event Loop: Merkezi Koordinatör</h3><p><strong>Event Loop</strong>, Node.js’in kalbinde yer alır ve senkron ve asenkron kodların düzgün bir şekilde çalışmasını sağlayan merkezi bir mekanizmadır. JavaScript'in tek iş parçacıklı yapısı nedeniyle, Event Loop, bu tek iş parçacığı üzerinde asenkron işlemleri koordine ederek verimli bir şekilde çalıştırır.</p><h4>Event Loop’un Görevleri:</h4><ul><li><p><strong>Koordinasyon:</strong> Event loop, senkron ve asenkron görevlerin ne zaman ve nasıl yürütüleceğini koordine eder.</p></li><li><p><strong>Callback Yürütme:</strong> Kuyruklarda bekleyen callback fonksiyonlarını yürütür.</p></li><li><p><strong>Görev Planlama:</strong> Asenkron görevlerin çalışma sırasını belirler ve uygun kuyruklara yerleştirir.</p></li></ul><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705744499/bg-forum/zfnkm4kae7puajlh72zg.webp" alt="Visualizing the event loop"><h4>Event Loop’un İşleyişi:</h4><p>Event Loop, Node.js uygulamanız çalıştığı sürece sürekli dönen bir döngüdür. Bu döngü, çeşitli kuyruklarda (queues) bulunan görevleri (tasks) belirli bir sırayla işler. Her döngüde, Event Loop şu adımları takip eder:</p><ol><li><p><strong>Microtask Queue:</strong> <code>process.nextTick</code> ve <code>Promise</code> callback'leri işlenir.</p></li><li><p><strong>Timer Queue:</strong> Zamanlayıcı (setTimeout, setInterval) callback'leri yürütülür.</p></li><li><p><strong>Microtask Queue:</strong> Timer görevlerinden sonra tekrar kontrol edilir.</p></li><li><p><strong>IO Queue:</strong> Asenkron I/O operasyonlarının callback'leri yürütülür.</p></li><li><p><strong>Microtask Queue:</strong> I/O görevlerinden sonra tekrar kontrol edilir.</p></li><li><p><strong>Check Queue:</strong> <code>setImmediate</code> fonksiyonunun callback'leri yürütülür.</p></li><li><p><strong>Microtask Queue:</strong> Check görevlerinden sonra tekrar kontrol edilir.</p></li><li><p><strong>Close Queue:</strong> Asenkron görevlerin kapanış olaylarına bağlı callback'ler yürütülür.</p></li><li><p><strong>Microtask Queue:</strong> Döngü sonunda tekrar kontrol edilir.</p></li></ol><p>Bu adımlar, her event loop döngüsünde tekrarlanır. Yeni görevler eklendikçe, event loop bu görevleri uygun kuyruklara ekler ve sırasıyla işler.</p><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705746409/bg-forum/rmdavp89kncvw3fc0ldj.gif" alt="event loop gif"><h3>Thread Pool: Yoğun İşlemlerin Yöneticisi</h3><p><strong>Thread Pool</strong>, Node.js'in asenkron işleme yeteneklerini genişleten bir bileşendir. Özellikle CPU yoğunluklu ve uzun süreli işlemleri yönetmek için kullanılır.</p><h4>Thread Pool’un Görevleri:</h4><ul><li><p><strong>Ağır İşlemler:</strong> CPU yoğunluklu işlemler (örneğin, dosya okuma/yazma, kriptografik işlemler) thread pool tarafından yürütülür.</p></li><li><p><strong>Bloklama İşlemleri:</strong> Uzun süren işlemler, ana iş parçacığını (event loop’u) engellememek için thread pool’da gerçekleştirilir.</p></li></ul><h4>Thread Pool’un İşleyişi:</h4><p>Event loop, ağır veya uzun süreli bir işlemi thread pool’a devrettiğinde, bu işlem bir iş parçacığında (thread) yürütülür. İşlem tamamlandığında, sonuç event loop’a iletilir ve ilgili callback fonksiyonu çalıştırılır. Bu sayede, ana iş parçacığı bloke edilmeden diğer görevler yürütülmeye devam eder.</p><h3>İşletim Sistemi: Düşük Seviyeli İşlemler</h3><p><strong>İşletim Sistemi</strong>, düşük seviyeli I/O işlemleri ve yerel asenkron mekanizmalarla doğrudan etkileşimde bulunur. İşletim sistemi, ağ istekleri, dosya sistemi erişimi gibi işlemleri yönetir.</p><h4>İşletim Sistemi’nin Görevleri:</h4><ul><li><p><strong>Yerel Asenkron Mekanizmalar:</strong> Ağ istekleri gibi düşük seviyeli I/O işlemlerini yönetir.</p></li><li><p><strong>Sistem Kaynak Yönetimi:</strong> Dosya sistemine erişim, ağ bağlantıları gibi kaynakları yönetir.</p></li></ul><h4>İşletim Sistemi’nin İşleyişi:</h4><p>İşletim sistemi, mümkün olduğunda I/O işlemlerini yerel asenkron mekanizmaları kullanarak gerçekleştirir. Bu işlemler tamamlandığında, sonuçlar libuv aracılığıyla event loop’a iletilir ve ilgili callback fonksiyonları çalıştırılır.</p><h3>Bileşenlerin Birlikte Çalışması</h3><p>Bu üç bileşen (Event Loop, Thread Pool ve İşletim Sistemi) birlikte çalışarak Node.js'in yüksek performanslı ve ölçeklenebilir bir platform olmasını sağlar.</p><h4>Görevlerin Dağılımı ve İş Birliği:</h4><ol><li><p><strong>Asenkron I/O İşlemleri:</strong></p><ul><li><p><strong>Başlatma:</strong> Event loop, bir I/O işlemi başlattığında (örneğin, dosya okuma), bu görev libuv tarafından işletim sistemine veya thread pool’a devredilir.</p></li><li><p><strong>Yürütme:</strong> İşletim sistemi, ağ istekleri gibi düşük seviyeli I/O işlemlerini yönetir. Thread pool, CPU yoğunluklu işlemleri yürütür.</p></li><li><p><strong>Sonuçların Bildirilmesi:</strong> İşletim sistemi veya thread pool, tamamlanan işlemlerin sonuçlarını event loop’a bildirir.</p></li><li><p><strong>İşleme:</strong> Event loop, sonuçları alır ve ilgili callback fonksiyonlarını yürütür.</p></li></ul></li><li><p><strong>CPU Yoğunluklu İşlemler:</strong></p><ul><li><p><strong>Başlatma:</strong> Event loop, CPU yoğunluklu bir işlemi thread pool’a devreder.</p></li><li><p><strong>Yürütme:</strong> Thread pool, bu işlemi bir iş parçacığında yürütür.</p></li><li><p><strong>Sonuçların Bildirilmesi:</strong> İşlem tamamlandığında, sonuç event loop’a iletilir.</p></li><li><p><strong>İşleme:</strong> Event loop, sonuçları alır ve ilgili callback fonksiyonlarını yürütür.</p></li></ul></li><li><p><strong>Zamanlayıcılar ve Diğer Asenkron Görevler:</strong></p><ul><li><p><strong>Başlatma:</strong> Zamanlayıcılar (örneğin, <code>setTimeout</code>) event loop tarafından zamanlayıcı kuyruğuna eklenir.</p></li><li><p><strong>Yürütme ve İşleme:</strong> Belirtilen süre dolduğunda, event loop ilgili callback fonksiyonlarını yürütür.</p></li></ul></li></ol><h3>Sonuç</h3><p>Node.js'teki Event Loop, Thread Pool ve İşletim Sistemi, asenkron işlemlerin koordinasyonunu sağlayarak yüksek performanslı ve ölçeklenebilir uygulamalar geliştirmeyi mümkün kılar. Event Loop, senkron ve asenkron kodların yürütülmesini koordine ederken, Thread Pool ağır ve uzun süreli işlemleri üstlenir. İşletim Sistemi ise düşük seviyeli I/O işlemlerini yönetir. Bu bileşenlerin etkili bir şekilde birlikte çalışması, Node.js'in gücünü ve esnekliğini ortaya koyar. Bu yapı, geliştiricilere daha verimli ve etkili kod yazma imkanı sunar ve Node.js'in popülerliğini artırır.</p>

Node.js’te Event Loop: Asenkron İşlemlerin Koordinasyonu

<p>Node.js, modern web uygulamalarının geliştirilmesinde tercih edilen bir platformdur, özellikle asenkron işlemlerin etkin bir şekilde yönetilmesi konusunda güçlüdür. Bu makalede, Node.js'te network I/O işlemlerinin nasıl işlendiğini ve Libuv'un bu işlemlerdeki rolünü inceleyeceğiz.</p><h3><strong>Libuv ve Asenkron İşlemler</strong></h3><p>Node.js, dosya okuma/yazma (<code>readFile</code>) ve şifreleme (<code>pbkdf2</code>) gibi işlemleri yürütmek için Libuv'un thread pool mekanizmasını kullanır. Bu işlemler, Node.js'in ana iş parçacığının bloklanmasını önlemek için Libuv'un thread pool'unda, yani ayrı iş parçacıklarında gerçekleştirilir.</p><h3><strong>Network I/O ve Libuv'un Rolü</strong></h3><p>Ancak, <code>https.request</code> gibi network I/O işlemlerinde durum farklıdır. Node.js, bu tür işlemleri gerçekleştirirken Libuv'un thread pool'unu kullanmaz. Bunun yerine, network I/O işlemleri, işletim sisteminin çekirdeğine (kernel) devredilir ve bu çekirdek, işlemleri asenkron olarak yönetir.</p><h4>HTTPS İstekleri Örneği</h4><p>Aşağıdaki kod örneği, <code>https.request</code> metodunu kullanarak Google'a HTTPS istekleri yapar. Maksimum çağrı sayısı (MAX_CALLS) 12'ye ayarlanmıştır ve her bir isteğin işlenme süresi kaydedilir:</p><pre><code>const https = require("node:https");

const CALL_LIMIT = 12;

const start = Date.now();
for (let i = 0; i &lt; CALL_LIMIT; i++) {
  https.request("https://www.google.com", (res) =&gt; {
    res.on("data", () =&gt; {});
    res.on("end", () =&gt; {
      console.log(`Request: ${i + 1}`, Date.now() - start);
    })
  }).end();
}</code></pre><p>Bu örnekte, çağrı sayısının 1'den 12'ye kadar artırılmasına rağmen, her isteğin işlenme süresi ortalama olarak 200-300 milisaniye arasında değişti. Bu, <code>https.request</code> metodunun Libuv'un thread pool'unu kullanmadığını gösterir.</p><h3><strong>İşletim Sistemlerine Özgü Asenkron Mekanizmalar</strong></h3><p>İşletim sistemleri, network I/O işlemleri için kendi asenkron mekanizmalarını kullanır:</p><ul><li><p><strong>Linux</strong>: <code>epoll</code>, yüksek sayıda ağ bağlantısını etkin bir şekilde yönetebilen bir I/O olay bildirim mekanizmasıdır.</p></li><li><p><strong>macOS</strong>: <code>kqueue</code>, çeşitli türde olayları izlemek için kullanılan bir mekanizmadır.</p></li><li><p><strong>Windows</strong>: I/O Tamamlama Bağlantı Noktaları (I/O Completion Ports - IOCP), yüksek performanslı I/O işlemleri için bir model sunar.</p></li></ul><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705677097/bg-forum/myucq9uahaxnw8dv8s5w.png" alt="node.js i/o network"><p>Bu mekanizmalar, Node.js uygulamalarının ağ I/O işlemlerini verimli bir şekilde yönetmesini ve ölçeklendirmesini sağlar. İşletim sistemi çekirdeğinin bu asenkron işlemleri yönetmesi, Node.js uygulamalarının yüksek trafikli durumlarda bile hızlı ve verimli kalmasını sağlar.</p><h3><strong>Sonuç</strong></h3><p>Node.js, ağ I/O işlemlerinde Libuv'un thread pool'unu kullanmaktan ziyade, işletim sisteminin asenkron I/O mekanizmalarına güvenir. Bu yaklaşım, ağ isteklerinin ve yanıtlarının yüksek verimlilikle işlenmesini sağlar ve Node.js'in ana iş parçacığının bu süreçte bloklanmadan diğer görevlere devam etmesine olanak tanır. Bu özellik, Node.js'in ağ tabanlı uygulamalar için ideal bir platform olmasının temel nedenlerinden biridir. CPU yoğun işlemler ve dosya I/O işlemleri için Libuv thread pool kullanılırken, network I/O gibi işlemler için işletim sisteminin yerleşik asenkron özellikleri tercih edilir. Bu, Node.js uygulamalarının performansını ve ölçeklenebilirliğini artıran önemli bir faktördür.</p>

Node.js'de Network I/O İşlemleri ve Libuv'un Rolü

<p>Node.js, tek iş parçacıklı bir çalışma zamanı ortamı olarak bilinir, ancak bazı ağır hesaplamalar ve I/O operasyonları için arka planda bir thread pool kullanır. Bu makalede, Node.js'te thread pool boyutunun nasıl ayarlandığını, performansı nasıl etkilediğini ve bu süreçte karşılaşılabilecek bazı sorunları inceleyeceğiz. Ayrıca, örnek kodlar ve deneyler üzerinden bu kavramları detaylı olarak açıklayacağız.</p><h3>Libuv Thread Pool Nedir?</h3><p>Libuv, Node.js'in altında yatan I/O ve asenkron işlemleri yöneten bir kütüphanedir. Libuv, özellikle ağ işlemleri, dosya sistemi erişimleri ve bazı kriptografik işlemler gibi CPU yoğun işlemleri ana iş parçacığından alıp bir thread pool'a atayarak yönetir. Bu sayede, ana iş parçacığı diğer işlerle meşgulken ağır işlemler arka planda çalışabilir.</p><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705664356/bg-forum/mdhnglffe6vunw32utr2.png" alt="libuv thread pool"><h3>Thread Pool Varsayılan Boyutu</h3><p>Varsayılan olarak, Node.js'te Libuv thread pool'unun boyutu dört thread'dir. Bu, dört asenkron işlemin paralel olarak çalışabileceği anlamına gelir. Ancak, bu boyut bazen yetersiz kalabilir ve performans sorunlarına yol açabilir.</p><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705664843/bg-forum/a0q6t1dno7a6zgibqwl6.png" alt="libuv thread pool"><p><strong>Örnek Kod</strong></p><pre><code>const fs = require("node:fs");
const crypto = require("node:crypto");

console.log("Başlangıç");

fs.readFile("file.txt", "utf-8", (err, data) =&gt; {
  if (err) throw err;
  console.log(data);
});

console.log("Bitiş");</code></pre><p>Yukarıdaki kodda, <code>fs.readFile</code> asenkron bir I/O işlemi olarak thread pool kullanırken, <code>crypto.pbkdf2Sync</code> senkron bir CPU yoğun işlemdir ve thread pool kullanmaz.</p><h4>Thread Pool Boyutunu Artırma</h4><p>Node.js'te thread pool boyutunu artırarak performansı iyileştirebiliriz. Bunu yapmak için <code>process.env.UV_THREADPOOL_SIZE</code> ortam değişkenini kullanabiliriz.</p><p><strong>Örnek Kod</strong></p><p>Aşağıdaki örnekte, thread pool boyutunu beş olarak ayarlayıp <code>crypto.pbkdf2</code> fonksiyonunu beş kez çağırıyoruz:</p><pre><code>const crypto = require("node:crypto");

process.env.UV_THREADPOOL_SIZE = 5; // Bu satırın üstte olduğundan emin olun

const start = Date.now();
const CALL_LIMIT = 5;

for (let i = 0; i &lt; CALL_LIMIT; i++) {
  crypto.pbkdf2("password", "salt", 100000, 512, "sha512", () =&gt; {
    console.log(`Süre: ${Date.now() - start} ms`);
  });
}

console.log("async");</code></pre><p>Bu kodda, beş asenkron <code>pbkdf2</code> işlemi paralel olarak çalışır ve her biri thread pool'daki bir thread'i kullanır. Bu sayede işlemler daha hızlı tamamlanır.</p><p><strong>Deneyler ve Gözlemler</strong></p><ol><li><p><strong>Varsayılan Boyut: 4 Thread</strong></p></li></ol><pre><code>const crypto = require("node:crypto");

const start = Date.now();
const CALL_LIMIT = 5;

for (let i = 0; i &lt; CALL_LIMIT; i++) {
  crypto.pbkdf2("password", "salt", 100000, 512, "sha512", () =&gt; {
    console.log(`Süre: ${Date.now() - start} ms`);
  });
}

console.log("async");</code></pre><p>Bu durumda, beşinci işlem diğerlerinden daha uzun sürer çünkü ilk dört işlem kendi thread'lerinde çalışırken beşinci işlem, bir thread'in boşalmasını bekler.</p><ol start="2"><li><p><strong>Thread Pool Boyutunu Artırma: 5 Thread</strong></p><pre><code>const crypto = require("node:crypto");

process.env.UV_THREADPOOL_SIZE = 5;

const start = Date.now();
const CALL_LIMIT = 5;

for (let i = 0; i &lt; CALL_LIMIT; i++) {
  crypto.pbkdf2("password", "salt", 100000, 512, "sha512", () =&gt; {
    console.log(`Süre: ${Date.now() - start} ms`);
  });
}

console.log("async");</code></pre><p>Bu durumda, tüm işlemler neredeyse aynı sürede tamamlanır, çünkü her işlem kendi thread'inde çalışır.</p></li><li><p><strong>CPU Çekirdeklerini Aşma: 16 Thread</strong></p><pre><code>const crypto = require("node:crypto");

process.env.UV_THREADPOOL_SIZE = 16;

const start = Date.now();
const CALL_LIMIT = 16;

for (let i = 0; i &lt; CALL_LIMIT; i++) {
  crypto.pbkdf2("password", "salt", 100000, 512, "sha512", () =&gt; {
    console.log(`Süre: ${Date.now() - start} ms`);
  });
}

console.log("async");</code></pre><p>Bu durumda, işlemler daha uzun sürer çünkü işletim sistemi, 16 thread'i 8 çekirdek üzerinde dağıtmak zorunda kalır. Bu, her işlemin tamamlanma süresini artırır.</p></li></ol><h3><strong>Gerçek Dünya Senaryosu: Yüksek Trafikli Web Sunucusu</strong></h3><p>Bir web sunucusu örneğini ele alalım. Sunucu, yoğun olarak CPU'yu kullanan işlemler gerçekleştiriyor ve bu işlemler Node.js'in thread pool'u tarafından yönetiliyor. Eğer sunucuda aynı anda çok sayıda CPU yoğun işlem gerçekleşiyorsa ve thread pool yetersizse, işlemler sırayla işlenir ve yanıt süreleri uzar. Bu durumda, thread pool boyutunu, sunucunuzun CPU çekirdek sayısına uygun bir şekilde artırmak, paralel işlem kapasitesini artırır ve işlem sürelerini azaltır. Ancak, CPU çekirdek sayısından fazla bir thread pool boyutu ayarlamak, işlemciyi gereksiz yere yorar ve performansı düşürebilir.</p><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705665011/bg-forum/i8sgzy0efhkqva3t0ypk.png" alt="libuv thread pool"><h3><strong>CPU Çekirdek Sayısı ve Thread Pool Boyutunun Dengesi</strong></h3><p>CPU çekirdek sayısından daha fazla bir thread pool boyutu ayarlamak, performans üzerinde olumsuz etkilere yol açabilir. Örneğin, 8 çekirdekli bir bilgisayarda thread pool boyutunu 16'ya çıkarmak, işletim sisteminin daha fazla thread'i yönetmek için daha fazla kaynak harcaması gerektirdiği anlamına gelir. Bu durum, işlem süresinin artmasına neden olur.</p><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1705664937/bg-forum/cn9fnpi9kdgvph0btlg7.png" alt="libuv thread pool"><h4>Sonuç</h4><p>Thread pool boyutunu artırmak, doğru şekilde yapıldığında performansı iyileştirebilir. Ancak, bu ayarın CPU çekirdek sayısına göre yapılması önemlidir. Aksi takdirde, beklenmedik performans düşüşleri yaşanabilir.</p><h4>Özet</h4><ul><li><p>Node.js, bazı ağır işlemleri Libuv thread pool kullanarak yönetir.</p></li><li><p>Varsayılan olarak dört thread ile çalışır, ancak <code>process.env.UV_THREADPOOL_SIZE</code> kullanarak bu boyutu artırabiliriz.</p></li><li><p>Thread pool boyutunu artırmak performansı iyileştirebilir, ancak thread sayısı CPU çekirdek sayısını aşarsa performans düşüşü yaşanabilir.</p></li></ul><p>Bu makalede, Node.js'te thread pool boyutunu nasıl ayarlayacağınızı ve performansı nasıl optimize edeceğinizi öğrendik. Bu bilgiler, uygulamalarınızın daha verimli çalışmasına yardımcı olabilir.</p>

Node.js Thread Pool Boyutu ve Performans Üzerindeki Etkileri

<p>Node.js, JavaScript tabanlı sunucu tarafı uygulamalar geliştirmek için kullanılan popüler bir platformdur. Asenkron ve non-blocking yapısıyla öne çıkan Node.js, yüksek performanslı ve ölçeklenebilir uygulamalar geliştirilmesine olanak tanır. Bu makalede, Node.js'in bu özelliklerini mümkün kılan temel bileşenlerden biri olan <strong>thread pool</strong> (iş parçacığı havuzu) ve <strong>libuv</strong> kütüphanesi hakkında detaylı bilgi verilecektir.</p><h4>Asenkron ve Non-blocking Yapının Temelleri</h4><p>Node.js, tek iş parçacıklı bir çalışma modeline sahiptir. Bu, tüm JavaScript kodunun tek bir iş parçacığı üzerinde çalıştığı anlamına gelir. Peki, zaman alan işlemler sırasında ana iş parçacığının bloklanmasını nasıl engeller? İşte burada asenkron ve non-blocking (engellemesiz) yapı devreye girer.</p><p>Asenkron ve non-blocking yapı sayesinde, zaman alan işlemler ana iş parçacığını bloklamadan arka planda gerçekleştirilebilir. Örneğin, dosya okuma veya HTTP istekleri gibi işlemler asenkron olarak gerçekleştirilir. Bu sayede, ana iş parçacığı diğer işlemleri gerçekleştirmeye devam edebilir.</p><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1718803690/bg-forum/gpqzaznakofdoxswor9g.gif" alt="thread pool"><h5><strong>FS Modülü ile Asenkron Dosya Okuma</strong></h5><pre><code>const fs = require('fs');

console.log('Başlangıç');

fs.readFile('dosya.txt', 'utf8', (err, data) =&gt; {
    if (err) throw err;
    console.log(data);
});

console.log('Bitiş');</code></pre><p>Yukarıdaki kodda, <code>fs.readFile</code> metodu kullanılarak bir dosya asenkron olarak okunur. Kod çalıştırıldığında, <code>Başlangıç</code> ve <code>Bitiş</code> mesajları sırasıyla konsola yazdırılır. Dosya okuma işlemi tamamlandığında ise dosyanın içeriği konsola yazdırılır. Bu, asenkron yapının bir örneğidir: dosya okuma işlemi arka planda gerçekleştirilirken ana iş parçacığı çalışmaya devam eder.</p><h4>Libuv ve Thread Pool</h4><p>Node.js'in asenkron ve non-blocking yapısını sağlayan temel bileşenlerden biri <strong>libuv</strong> kütüphanesidir. Libuv, Node.js'in altında yatan düşük seviye kütüphanedir ve asenkron I/O işlemlerini yönetir. İş parçacığı havuzu, genellikle zaman alan dosya sistem erişimleri veya kriptografik işlemler gibi CPU yoğun görevler için kullanılır.</p><h5><strong>İş Parçacığı Havuzunun İşleyişi</strong></h5><p>Libuv, iş parçacığı havuzu (thread pool) kullanarak zaman alan görevleri ana iş parçacığından bağımsız olarak çalıştırır. İş parçacığı havuzu, varsayılan olarak dört iş parçacığı içerir, ancak ihtiyaçlara göre konfigüre edilebilir. Ana iş parçacığı, zaman alan bir görevle karşılaştığında, görevi libuv'ye devreder ve libuv, bu görevi iş parçacığı havuzundaki uygun bir iş parçacığına atar.</p><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1718804134/bg-forum/y1wnlsfi2ao93vuypnze.png" alt="libuv"><p>Örneğin, dosya okuma işlemi aşağıdaki gibi libuv tarafından iş parçacığı havuzuna atanabilir:</p><pre><code>fs.readFile('dosya.txt', 'utf8', (err, data) =&gt; {
    if (err) throw err;
    console.log(data);
});</code></pre><p>Bu işlem, libuv tarafından iş parçacığı havuzuna atanır ve bir iş parçacığı bu görevi tamamlar. Görev tamamlandığında, ilgili geri çağırım fonksiyonu (callback) çalıştırılır.</p><h4>Kriptografi ve CPU Yoğun İşlemler</h4><p>Node.js'in <code>crypto</code> modülü, güvenli kriptografik işlemler gerçekleştirmek için kullanılır. Özellikle <code>crypto.pbkdf2</code> (Password-Based Key Derivation Function 2) metodu, şifrelerin güvenli bir şekilde hash edilmesini sağlar. Bu metod, oldukça CPU yoğun bir işlemdir ve bu nedenle iş parçacığı havuzunu kullanarak ana iş parçacığının bloklanmasını önler.</p><h5><strong>PBKDF2 Metodunun Kullanımı</strong></h5><pre><code>const crypto = require('crypto');

const start = Date.now();

crypto.pbkdf2('password', 'salt', 100000, 64, 'sha512', (err, derivedKey) =&gt; {
    if (err) throw err;
    console.log(`Türetilmiş anahtar: ${derivedKey.toString('hex')}`);
    console.log(`Süre: ${Date.now() - start} ms`);
});</code></pre><p>Yukarıdaki kodda, <code>crypto.pbkdf2</code> metodu kullanılarak bir şifre hash edilir. Bu işlem CPU yoğun bir işlem olduğundan, libuv tarafından iş parçacığı havuzuna atanır ve ana iş parçacığı bloklanmadan diğer işlemleri gerçekleştirmeye devam edebilir.</p><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1718803726/bg-forum/kuftyoykteth7znhmayq.png" alt="thread pool"><h4>Performans Ölçümleri ve Karşılaştırmalar</h4><p>Asenkron ve senkron metodlar arasındaki performans farkını anlamak için birkaç deney gerçekleştirelim.</p><h5>Senkron Metodların Performansı</h5><p>Senkron metodlar, ana iş parçacığını bloklayarak çalışır. Örneğin, <code>crypto.pbkdf2Sync</code> metodu senkron olarak çalışır ve ana iş parçacığını bloklar.</p><pre><code>const start = Date.now();

const key = crypto.pbkdf2Sync('password', 'salt', 100000, 64, 'sha512');
console.log(`Türetilmiş anahtar: ${key.toString('hex')}`);
console.log(`Süre: ${Date.now() - start} ms`);</code></pre><p>Bu kod çalıştırıldığında, <code>pbkdf2Sync</code> metodu tamamlanana kadar ana iş parçacığı bloklanır ve diğer işlemler gerçekleştirilmez.</p><h5>Asenkron Metodların Performansı</h5><p>Asenkron metodlar, iş parçacığı havuzunu kullanarak çalışır ve ana iş parçacığını bloklamaz. Yukarıda verilen <code>crypto.pbkdf2</code> örneği, asenkron metodun nasıl çalıştığını göstermektedir.</p><p>Bu metod, iş parçacığı havuzunda bir iş parçacığı tarafından gerçekleştirilir ve ana iş parçacığı diğer işlemleri gerçekleştirmeye devam eder. Bu sayede, aynı anda birden fazla asenkron işlem gerçekleştirilerek paralel işlem yapılabilir.</p><h4>Sonuç ve Özet</h4><p>Node.js'in asenkron ve non-blocking yapısı, yüksek performanslı ve ölçeklenebilir uygulamalar geliştirilmesine olanak tanır. Bu yapının temel bileşenlerinden biri olan libuv ve iş parçacığı havuzu, zaman alan işlemleri ana iş parçacığından bağımsız olarak gerçekleştirir. Bu sayede, ana iş parçacığı bloklanmadan diğer işlemleri gerçekleştirebilir.</p><p>Node.js'in bu özellikleri, özellikle yüksek trafik alan web uygulamaları ve gerçek zamanlı uygulamalar geliştirmek için idealdir. İş parçacığı havuzunun verimli kullanımı ve asenkron metodların doğru şekilde uygulanması, performansın ve kullanıcı deneyiminin optimize edilmesine yardımcı olur.</p><p>Gelecekte daha karmaşık konulara geçmeden önce, bu temel bilgileri anlamak Node.js ile etkili ve verimli kod yazmanın ilk adımıdır. Bu bilgileri pekiştirmek ve daha ileri seviye konuları öğrenmek için pratik yapmak ve Node.js dokümantasyonuna başvurmak önemlidir.</p>

Node.js ve Thread Pool: Asenkron İşlemlerin Temelleri

<p>Node.js, hızlı ve ölçeklenebilir ağ uygulamaları oluşturmak için kullanılan popüler bir JavaScript çalışma zamanı ortamıdır. Bu başarının arkasındaki önemli unsurlardan biri, C dilinde yazılmış olan ve Node.js'nin asenkron, non-blocking (engelleyici olmayan) işlemlerini yöneten libuv kütüphanesidir. Bu makalede, libuv'nin ne olduğunu, neden gerekli olduğunu ve nasıl çalıştığını ayrıntılı bir şekilde inceleyeceğiz.</p><h4>libuv Nedir?</h4><p>Libuv, çok platformlu (cross-platform) ve açık kaynak kodlu bir kütüphanedir. Başlangıçta Node.js için geliştirilmiş olsa da, diğer projelerde de yaygın olarak kullanılmaktadır. Libuv'nin temel amacı, asenkron I/O işlemlerini (girdi/çıktı işlemleri) yönetmek ve bu işlemlerin işletim sistemi düzeyindeki karmaşıklığını uygulama geliştiricilerinden gizlemektir. Libuv, bu karmaşıklığı yönetmek için iki ana mekanizma kullanır: Thread pool (iş parçacığı havuzu) ve event loop (olay döngüsü).</p><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1718793075/bg-forum/edoyewgkis5lfk2su1bs.png" alt="node libuv"><p><strong>Libuv İsminin Kökeni ve Anlamı</strong></p><p>Libuv'nin ismi, "library for Unix and V8" (Unix ve V8 için kütüphane) kelimelerinden gelmektedir. Bu isim, libuv'nin Node.js'nin ihtiyaçlarını karşılamak üzere tasarlandığını ve iki ana bileşene dayandığını ifade eder:</p><ol><li><p><strong>Unix:</strong> Libuv, çok platformlu bir kütüphane olduğu için Unix tabanlı sistemlerle uyumludur. Bununla birlikte, Windows gibi diğer işletim sistemlerini de destekler. Bu çok platformlu desteği sayesinde, Node.js uygulamaları farklı işletim sistemlerinde tutarlı bir şekilde çalışabilir.</p></li><li><p><strong>V8:</strong> V8, Google tarafından geliştirilen ve Node.js'nin JavaScript motoru olarak kullanılan yüksek performanslı bir JavaScript motorudur. Libuv, V8 motorunun üzerinde çalışarak, Node.js'nin asenkron I/O işlemlerini yönetmesine olanak tanır. V8'in hızını ve verimliliğini kullanarak, Node.js'nin yüksek performanslı asenkron işlemleri gerçekleştirmesine yardımcı olur.</p></li></ol><p>Libuv, bu iki bileşenin ihtiyaçlarını karşılamak üzere tasarlanmış ve adını bu bileşenlerden almıştır. Bu isim, libuv'nin temel amaçlarını ve işlevlerini özetleyen bir nitelik taşır.</p><h4>Neden libuv'ye İhtiyaç Duyarız?</h4><p>Asenkron programlama, özellikle I/O işlemlerinde, uygulamanın performansını artırmak için kritik öneme sahiptir. Geleneksel, senkron programlama modellerinde, bir I/O işlemi gerçekleştirilirken işlemci bekler ve bu bekleme süresi boyunca diğer işlemler durur. Bu, özellikle yüksek trafikli sunucu uygulamalarında büyük bir performans darboğazına neden olur. Node.js, bu sorunu çözmek için asenkron programlama modelini benimsemiştir ve libuv, bu modelin temel yapı taşlarından biridir.</p><p>Libuv, asenkron işlemleri yöneterek, Node.js'nin aynı anda binlerce bağlantıyı verimli bir şekilde işleyebilmesini sağlar. Böylece, geliştiriciler, işletim sistemi seviyesindeki karmaşıklıkla uğraşmadan yüksek performanslı uygulamalar geliştirebilirler.</p><h4>libuv Nasıl Çalışır?</h4><p>Libuv'nin çalışma prensibi, iki ana bileşen üzerine kuruludur: thread pool ve event loop. Bu iki bileşen, asenkron işlemleri yönetmenin temel yollarını sağlar.</p><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1718793348/bg-forum/kwqqy197f8hujba6kcu0.gif" alt="node libuv"><h5><strong>Thread Pool</strong></h5><p>Thread pool, CPU'ya bağlı işlemlerin asenkron olarak yürütülmesini sağlar. Özellikle, dosya sistemi işlemleri, DNS sorguları ve bazı kriptografik işlemler gibi zaman alan işlemler, thread pool tarafından yönetilir. Bu işlemler, ana iş parçacığını bloke etmeden arka planda yürütülür. Thread pool, belirli sayıda iş parçacığından oluşur ve bu iş parçacıkları, görev kuyruğundan aldıkları işleri sırayla işler. Böylece, yoğun CPU işlemleri bile ana iş parçacığını bloke etmeden gerçekleştirilebilir.</p><h5><strong>Event Loop</strong></h5><p>Event loop, Node.js'nin kalbinde yer alır ve tüm asenkron işlemleri yönetir. Olay döngüsü, işlemleri sıraya koyar ve uygun olduklarında çalıştırır. Bu döngü, sürekli olarak çalışır ve olay kuyruğunda bekleyen görevleri işler. Event loop'un temel çalışma adımları şu şekildedir:</p><ol><li><p><strong>Timers (Zamanlayıcılar):</strong> setTimeout ve setInterval gibi zamanlayıcı işlevleri kontrol eder ve süresi dolanları yürütür.</p></li><li><p><strong>I/O Callbacks (I/O Geri Aramaları):</strong> Tamamlanan I/O işlemlerinin geri aramalarını yürütür.</p></li><li><p><strong>Idle, Prepare:</strong> İç işlemler için ayrılmış adımlardır.</p></li><li><p><strong>Poll (Anket):</strong> Yeni I/O olaylarını bekler ve mevcut I/O olaylarını işler.</p></li><li><p><strong>Check:</strong> setImmediate geri aramalarını yürütür.</p></li><li><p><strong>Close Callbacks (Kapatma Geri Aramaları):</strong> Kapatma olayları için geri aramaları işler, örneğin soket kapanışları.</p></li></ol><p>Event loop, bu adımları döngüsel olarak tekrarlar ve her bir adımda, sıradaki uygun görevleri işler. Bu sayede, Node.js tek bir iş parçacığında çalışırken bile yüksek performanslı asenkron işlemleri yönetebilir.</p><h4>Sonuç</h4><p>Libuv, Node.js'nin başarısının ardındaki kritik bileşenlerden biridir. Asenkron ve non-blocking işlemleri yöneterek, Node.js'nin yüksek performanslı ve ölçeklenebilir uygulamalar geliştirmesine olanak tanır. Libuv'nin thread pool ve event loop gibi mekanizmaları, bu işlemleri verimli bir şekilde yönetir ve geliştiricilere karmaşık I/O işlemlerini kolayca gerçekleştirme imkanı sunar.</p><p>Libuv'yi ve onun sağladığı olanakları anlamak, Node.js ile geliştirme yaparken büyük bir avantaj sağlar. Bu temel bilgilerle, Node.js'nin asenkron doğasını daha iyi kavrayabilir ve daha verimli uygulamalar geliştirebilirsiniz. Bir sonraki adımda, thread pool ve event loop'un detaylarına daha derinlemesine bakarak, bu mekanizmaların nasıl çalıştığını ve Node.js'deki rollerini daha iyi anlayacağız.</p>

Node.js libuv Nedir ve Nasıl Çalışır?

<p>Node.js, tarayıcı dışında JavaScript çalıştırmak için tasarlanmış güçlü bir çalışma zamanıdır. Bu makalede, Node.js'nin iç yapılarını ve JavaScript'in asenkron özelliklerini özetleyeceğiz. Öncelikle Node.js çalışma zamanının bileşenlerine ve ardından JavaScript'in temel özelliklerine ve asenkron davranışına odaklanacağız.</p><h4>Node.js Çalışma Zamanı</h4><p>Node.js çalışma zamanı, JavaScript programlarını tarayıcı dışında çalıştırmak için gerekli tüm bileşenleri sağlayan bir ortamdır. Bu ortamın temel bileşenleri şunlardır:</p><img class="mx-auto" src="http://res.cloudinary.com/techprivil/image/upload/v1718784789/bg-forum/mjvmr3boqmpy8rb3lp5y.png" alt="node runtime"><ol><li><p><strong>Harici Bağımlılıklar</strong>:</p><ul><li><p><strong>V8</strong>: Google tarafından geliştirilen ve JavaScript kodunu makine koduna dönüştüren bir JavaScript motorudur. V8, yüksek performanslı JavaScript yürütmesi sağlar ve Node.js'nin çekirdek bileşenlerinden biridir.</p></li><li><p><strong>libuv</strong>: Asenkron I/O işlemleri ve olay döngüsü yönetimi gibi düşük seviyeli görevleri yerine getiren bir kütüphanedir. libuv, Node.js'nin asenkron olay tabanlı mimarisini mümkün kılarak, yüksek verimli ve ölçeklenebilir uygulamalar geliştirilmesine olanak tanır.</p></li></ul></li><li><p><strong>C++ Özellikleri</strong>:</p><ul><li><p>Node.js, düşük seviyeli sistem görevlerini gerçekleştirmek için C++ ile yazılmış bazı özelliklere sahiptir. Bu özellikler arasında dosya sistemi erişimi, ağ işlemleri ve diğer sistem kaynaklarına erişim bulunur. Bu sayede, Node.js JavaScript kütüphanesi üzerinden bu özelliklere erişim sağlanabilir.</p></li></ul></li><li><p><strong>JavaScript Kütüphanesi</strong>:</p><ul><li><p>Bu kütüphane, JavaScript kodundan C++ özelliklerine erişim sağlayan işlevler ve yardımcı araçlar içerir. JavaScript kütüphanesi, arka planda V8 motorunu kullanarak çalışır ve geliştiricilerin yüksek seviyeli JavaScript kodu ile düşük seviyeli sistem görevlerini gerçekleştirmesine olanak tanır.</p></li></ul></li></ol><h4>Asenkron JavaScript</h4><p>JavaScript, temel formunda eşzamansız, engelleyici ve tek iş parçacıklı bir dildir. Bu özellikler, JavaScript'in çalışma şekli hakkında önemli ipuçları verir:</p><ol><li><p><strong>Eşzamansız (Synchronous)</strong>:</p><ul><li><p>JavaScript kodu, üstten aşağı doğru çalıştırır ve her seferinde yalnızca bir satır yürütülür. Örneğin, iki fonksiyonun konsola mesaj yazdırması durumunda, ilk fonksiyonun çıktısı her zaman ikinci fonksiyonun çıktısından önce gelir. Bu, JavaScript'in doğal eşzamansız davranışını gösterir.</p></li></ul></li><li><p><strong>Engelleyici (Blocking)</strong>:</p><ul><li><p>JavaScript'in eşzamansız doğası nedeniyle, önceki işlem ne kadar uzun sürerse sürsün, sonraki işlem ancak önceki işlem tamamlandıktan sonra başlar. Örneğin, bir fonksiyon yoğun bir kod parçasını yürütüyorsa, bu kod parçası tamamlanana kadar JavaScript diğer fonksiyonları çalıştırmaz. Bu durum tarayıcıda bir web uygulaması çalışırken tarayıcının donmuş gibi görünmesine neden olabilir. Bu tür durumlar, JavaScript'in engelleyici doğasının bir sonucudur.</p></li></ul></li><li><p><strong>Tek İş Parçacıklı (Single Threaded)</strong>:</p><ul><li><p>Bir iş parçacığı, JavaScript programının bir görevi yürütmek için kullandığı bir süreçtir ve her iş parçacığı aynı anda yalnızca bir görev gerçekleştirebilir. JavaScript, bazı dillerin aksine çoklu iş parçacığını desteklemez ve kodu yürütmek için yalnızca ana iş parçacığını kullanır. Bu, JavaScript'in doğal olarak tek iş parçacıklı bir dil olduğunu gösterir.</p></li></ul></li></ol><h4>Node.js ve Asenkron Davranış</h4><p>Eğer JavaScript bu kadar kısıtlayıcı ise, <code>fs.readFile</code> veya <code>http.createServer</code> gibi yöntemlerin asenkron davranışını nasıl açıklarız? Bu noktada, sadece JavaScript'in kendisi bu asenkron davranışı açıklamak için yeterli değildir. Node.js, JavaScript'in dışında yeni parçalara ihtiyaç duyar ve bu parçalardan biri de harici bağımlılık olan <strong>libuv</strong>'dir.</p><p>Libuv, Node.js'nin asenkron olay tabanlı mimarisinin temelini oluşturur. Bu kütüphane, asenkron I/O işlemlerini yönetir ve Node.js'nin yüksek performanslı, ölçeklenebilir uygulamalar geliştirmesine olanak tanır. Libuv, olay döngüsü yönetimi, asenkron I/O işlemleri ve diğer düşük seviyeli görevleri yerine getirir.</p><h4>Sonuç</h4><p>Node.js çalışma zamanı, JavaScript'in sınırlarını aşarak tarayıcı dışında yüksek performanslı uygulamalar geliştirilmesini mümkün kılan bir ortamdır. V8 motoru, libuv kütüphanesi ve C++ özellikleri sayesinde Node.js, geliştiricilere güçlü ve esnek bir platform sunar. JavaScript'in eşzamansız, engelleyici ve tek iş parçacıklı doğası, Node.js'nin sağladığı bu bileşenlerle birlikte ele alındığında, geliştiricilerin yüksek verimli ve ölçeklenebilir uygulamalar geliştirmesine olanak tanır.</p><p>Bu makalede, Node.js çalışma zamanı ve JavaScript'in asenkron özellikleri hakkında detaylı bir inceleme sunduk. Node.js ve JavaScript'in bu temel özelliklerini anlamak, daha verimli ve etkili kod yazmanıza yardımcı olacaktır.</p>

Node Runtime Özeti

<h4>HTTP Modülü ile Routing İşlemleri</h4><p>Bu yazımızda, Node.js'in HTTP modülü kullanarak nasıl routing (yönlendirme) işlemleri yapabileceğimizi öğreneceğiz. Şu anki uygulamamızda, farklı URL'lere gidildiğinde hep aynı yanıtı alıyoruz. Ancak, bir web sitesinde farklı URL'ler genellikle farklı içerikler gösterir. Örneğin, <code>/about</code> adresi hakkında bilgi veren bir sayfa sunarken, <code>/api</code> adresi JSON verisi döndürebilir. Bu dersimizde, bu tür davranışları nasıl simüle edebileceğimizi göreceğiz.</p><h4>Uygulama Adımları ve Kod Örneği</h4><ol><li><p>İlk adım olarak, <code>req.url</code> özelliği ile gelen URL sorgu dizgisini alıyoruz.</p></li><li><p>Daha sonra bu URL'ye göre farklı yanıtlar vermek için if-else veya switch ifadelerini kullanacağız.</p></li><li><p>Eğer URL <code>/</code> (ana sayfa) ise, düz metin olarak "Ana Sayfa" yanıtı vereceğiz.</p></li><li><p>Eğer URL <code>/products</code> ise, "Ürünler Sayfası" yanıtını vereceğiz.</p></li><li><p>Eğer URL <code>/api</code> ise, JSON formatında veri döndüreceğiz. Örneğin, <code>{ firstName: "Emin", lastName: "Başbayan" }</code> gibi.</p></li><li><p>Eğer URL bu seçeneklerle eşleşmiyorsa, 404 durum kodu ile "Sayfa bulunamadı!" mesajını döndüreceğiz.
</p></li></ol><pre><code>const http = require("node:http");
const fs = require("node:fs");

const server = http.createServer((req, res) =&gt; {
  if (req.url === "/") {
    res.writeHead(200, { "Content-Type": "text/plain" });
    res.end("Home Page");
  } else if (req.url === "/products") {
    res.writeHead(200, { "Content-Type": "text/plain" });
    res.end("Products Page");
  } else if (req.url === "/api") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(
      JSON.stringify({
        firstName: "Emin",
        lastName: "Başbayan",
      })
    );
  } else {
    res.writeHead(404);
    res.end("Page not found!");
  }
});

server.listen(3000, () =&gt; {
  console.log("Server running on port 3000");
});</code></pre><h4>Sonuç ve İlerisi</h4><p>Bu basit örnekle, Node.js'in HTTP modülü kullanarak nasıl temel routing işlemleri yapabileceğimizi gördük. Ayrıca, <code>req.method</code> özelliği ile HTTP metodlarına (GET, POST, PUT, DELETE) göre de farklı işlemler yapabiliriz. Gerçek dünya uygulamalarında genellikle bu tür işlemler için web çatıları (frameworks) kullanılır. İlerleyen derslerde bu tür çatıları ve daha karmaşık routing işlemlerini inceleyeceğiz. Bu yazı, HTTP modülü ile temel routing işlemlerinin nasıl yapılabileceğine dair bir giriş niteliğindedir.</p>

Node.js HTTP Yönlendirme (Routing)

<p>Önceki yazıda, HTML ile statik sayfa yanıtları oluşturmayı öğrenmiş ve <code>fs</code> modülü kullanarak HTML dosyası okuma işlemini gerçekleştirmiştik. Statik HTML sayfalar sabit içeriğe sahiptir ve içerikleri değişmez. Ancak, bazı durumlarda HTML içerisine dinamik değerler eklememiz gerekebilir. Bu tür durumlar için basit bir çözüm olan string yerine koyma yöntemini kullanacağız.</p><h4>Dinamik İçerik Ekleme</h4><p>Bu örnekte, giriş yapan kullanıcının adını HTML sayfasında göstermeyi hedefliyoruz. Bu işlem için HTML şablonumuzda belirli yerlere özel işaretler (örneğin, <code>{{name}}</code>) yerleştiriyoruz ve bu işaretleri JavaScript kodumuzda dinamik değerlerle değiştiriyoruz.</p><h4>Uygulama Adımları ve Kod Örneği</h4><ol><li><p>JavaScript dosyamızda <code>name</code> adında bir sabit tanımlıyoruz ve bu sabiti "Emin" olarak ayarlıyoruz.</p></li><li><p>HTML dosyamızda <code>Hello {{name}}, welcome to Node.js</code> şeklinde bir ifade ekliyoruz.</p></li><li><p>JavaScript dosyamızda, <code>{{name}}</code> ifadesini <code>name</code> sabitiyle değiştiriyoruz.</p></li><li><p><code>fs.readFileSync</code> ile dosya içeriğini okuyup, bu içeriği bir <code>let</code> değişkenine atıyoruz.</p></li><li><p><code>html.replace</code> metodunu kullanarak <code>{{name}}</code> ifadesini <code>name</code> sabitiyle değiştiriyoruz.</p></li></ol><pre><code>const http = require("node:http");
const fs = require("node:fs");

const server = http.createServer((request, response) =&gt; {
  const name = "Emin";

  response.writeHead(200, { "Content-Type": "text/html" });
  let html = fs.readFileSync("./index.html", "utf-8");
  html = html.replace("{{name}}", name);
  response.end(html);
});

server.listen(3000, () =&gt; {
  console.log("Server running on port 3000");
});</code></pre><pre><code>&lt;!DOCTYPE html&gt;
&lt;html lang="en"&gt;
  &lt;head&gt;
    &lt;meta charset="UTF-8" /&gt;
    &lt;meta name="viewport" content="width=device-width, initial-scale=1.0" /&gt;
    &lt;title&gt;Node.js Eğitimi&lt;/title&gt;
  &lt;/head&gt;
  &lt;body&gt;
    &lt;h1&gt;Hello {{name}}, welcome to Node.js&lt;/h1&gt;
  &lt;/body&gt;
&lt;/html&gt;</code></pre><h4>Sonuç</h4><p>Bu yöntemle, HTML şablonlarına JavaScript kullanarak dinamik değerler ekleyebiliyoruz. Bu, Node.js'de HTML şablonları ile çalışmanın temel bir örneğidir. İlerleyen derslerde HTTP sunucusu üzerinde yönlendirme (routing) işlemlerini ele alacağız. Bu dersle, HTML şablonlarını kullanarak dinamik içerikler oluşturmanın temellerini öğrendik.</p>

Node.js HTML Şablonları ve Dinamik İçerik

<p>Node.js, web geliştirme dünyasında oldukça popüler bir platformdur. Bu makalede, Node.js kullanarak bir sunucudan nasıl HTML yanıtı göndereceğimizi öğreneceğiz.</p><h2><strong>JSON'dan HTML'ye Geçiş</strong></h2><p>Önceki videolarda JSON verisi göndermeyi öğrendik. Şimdi ise, HTML olarak yanıt göndermeye odaklanacağız. Basit bir "Hello World" metninden başlayarak, bu metni HTML'e nasıl dönüştüreceğimizi adım adım inceleyeceğiz.</p><h3><strong>İlk Adımlar</strong></h3><p>İlk olarak, basit bir düz metin yanıtı gönderiyoruz. Bu, çoğu Node.js başlangıç örneğinde gördüğümüz tipik bir yapıdır. İçerik türünü "text/plain" olarak belirleyerek basit bir metin gönderiyoruz:</p><pre><code>res.end("Hello World");</code></pre><p>Bu kod, sunucu yeniden başlatılıp tarayıcı yenilendiğinde "Hello World" metnini gösterir.</p><h3><strong>HTML İçeriğine Geçiş</strong></h3><p>Daha sonra, bu metni bir <code>&lt;h1&gt;</code> etiketi ile sarmalayarak HTML'e dönüştürüyoruz. Ancak, bu aşamada bir sorunla karşılaşıyoruz. Tarayıcı, yanıtı hala düz metin olarak algılıyor çünkü içerik türünü "text/html" olarak güncellememişiz. İçerik türünü güncellediğimizde, tarayıcı metni doğru bir şekilde HTML olarak işliyor ve büyük, kalın bir "Hello World" metni görüyoruz.</p><h3><strong>Daha Gelişmiş HTML Yanıtı</strong></h3><p>Sıradaki adımımız, JavaScript dosyasında doğrudan HTML oluşturmak yerine, ayrı bir HTML dosyası oluşturup bu dosyanın içeriğini yanıt olarak göndermektir. Bu yaklaşım, kodumuzu daha düzenli ve bakımı daha kolay hale getirir.</p><h4>Dosya Okuma</h4><p>Bu amaçla, Node.js'in <code>fs</code> modülünü kullanarak <code>index.html</code> adlı bir dosya oluşturuyor ve bu dosyanın içeriğini okuyoruz. Dosya okuma işlemi için <code>readFileSync</code> fonksiyonunu kullanıyoruz. Bu fonksiyon, dosya içeriğini okumayı tamamlayana kadar kodun geri kalanının çalışmasını durdurur. Dosya içeriği okunduktan sonra, bu içeriği HTML yanıtı olarak gönderiyoruz.</p><h4>Akışlar ve Performans</h4><p>Daha büyük HTML dosyaları ile çalışırken, <code>readFileSync</code> yerine akışları (<code>streams</code>) kullanmak daha verimli olabilir. Akışlar, dosyanın tamamını bir kerede belleğe yüklemek yerine, parça parça okuma yaparak bellek kullanımını optimize eder. Bu da uygulamanın performansını artırır.</p><h3><strong>Pratik İpuçları</strong></h3><ul><li><p>Dosya yolları belirtirken, genellikle <code>__dirname</code> kullanmak daha güvenlidir.</p></li><li><p>HTML içeriğinizi geliştirirken, CSS kullanarak stil ekleyebilirsiniz.</p></li><li><p>Sunucuyu her değişiklik yaptığınızda yeniden başlatmak yerine, "watch mode" özelliğini kullanabilirsiniz.</p></li></ul><h2><strong>Özet</strong></h2><p>Bu makalede, Node.js kullanarak basit bir HTML yanıtı nasıl hazırlanacağını öğrendik:</p><ol><li><p>Basit bir düz metin yanıtı göndermek.</p></li><li><p>HTML etiketleri ekleyerek yanıtı zenginleştirmek.</p></li><li><p>Ayrı bir HTML dosyası kullanarak daha düzenli kod yazmak.</p></li><li><p><code>fs</code> modülü ile dosya okuma işlemleri yapmak.</p></li><li><p>Performansı artırmak için akışları kullanmak.</p></li></ol><p>Bu teknikler, web uygulamalarınızda dinamik içerik oluşturmak ve sunmak için temel oluşturur. Node.js'in esnekliği sayesinde, HTML yanıtlarınızı daha da geliştirebilir ve kullanıcı deneyimini zenginleştirebilirsiniz.</p>

Node.js ile HTML Yanıtı Göndermek

<h3><strong>JSON Yanıtı Göndermek</strong></h3><p>Önceki yazıda Node.js'de dahili HTTP modülü ile nasıl HTTP sunucusu oluşturulacağını öğrenmiştik. O örnekte düz metinle nasıl yanıt verileceğini gördük. Bu yazıda, JSON verisiyle nasıl yanıt verileceğini öğreneceğiz.</p><h4>JSON Nedir?</h4><p>JSON, "JavaScript Object Notation" anlamına gelir ve HTTP ile kullanabileceğimiz bir veri alışverişi formatıdır. V8 motoru, JSON formatını destekleyen yerleşik işlevselliklere sahiptir.</p><h4>JSON ile Yanıt Oluşturma</h4><p>Öncelikle JSON olarak göndermek istediğimiz veriyi bir JavaScript nesnesi olarak oluşturalım:</p><pre><code>const instructor = {
    firstName: "Emin",
    lastName: "Başbayan"
};</code></pre><p>Bu nesneyi doğrudan yanıt olarak gönderemeyiz çünkü HTTP yanıtları genellikle metin formatındadır. Bu nedenle, nesneyi JSON formatına dönüştürmemiz gerekir. Bunun için <code>JSON.stringify</code> metodunu kullanırız:</p><pre><code>response.end(JSON.stringify(instructor));</code></pre><h4>İçerik Tipini Belirtmek</h4><p>Yanıtın içerik tipini 'application/json' olarak belirtmek, tarayıcının yanıtı doğru şekilde yorumlamasına yardımcı olur:</p><pre><code>response.writeHead(200, {'Content-Type': 'application/json'});</code></pre><p>Bu adımlarla, sunucumuz JSON formatında veri gönderen bir API endpoint'i olarak işlev görmeye başlar. Artık, bu veriyi almak isteyen herhangi bir istemci veya sunucu, uygulamamızdan bu veriyi isteyebilir.</p><h3><strong>Özet</strong></h3><p>Bu yazıda öğrendiklerimiz:</p><ol><li><p>JSON formatının ne olduğu ve neden kullanıldığı.</p></li><li><p>JavaScript nesnelerini JSON formatına dönüştürmek için <code>JSON.stringify</code> metodunun kullanımı.</p></li><li><p>Yanıtın içerik tipini 'application/json' olarak belirtmek.</p></li></ol><p>Bu bilgilerle, Node.js uygulamanızda JSON formatında veri gönderen API'ler oluşturabilirsiniz. İlerleyen yazılarda, Node.js ile API tasarımı hakkında daha fazla bilgi edineceğiz.</p>

Node.js JSON Yanıtı

<h3><strong>Node.js ile Web Sunucusu Nasıl Oluşturulur?</strong></h3><p>Önceki yazıda HTTP modülünü tanıtmıştık. Bu yazıda, HTTP modülünü kullanarak bir Node sunucusu nasıl oluşturulacağını kod üzerinden anlayacağız.</p><h4>Adım 1: Modülü İçe Aktarma</h4><p>Node.js'de HTTP modülünü içe aktarmak için şu kodu kullanırız:</p><pre><code>const http = require('node:http');</code></pre><h4>Adım 2: Sunucu Oluşturma</h4><p>HTTP modülünde bulunan <code>createServer</code> metodunu çağırarak sunucumuzu oluştururuz. Bu metod, bir geri çağırma (callback) fonksiyonu kabul eder:</p><pre><code>const server = http.createServer((request, response) =&gt; {
    // İstek ve yanıt işlemleri burada gerçekleşir.
});</code></pre><p>Bu geri çağırma fonksiyonu, her istek geldiğinde çalıştırılır. <code>request</code> nesnesi gelen isteğin bilgilerini içerirken, <code>response</code> nesnesi ile istemciye yanıt göndeririz.</p><h4>Adım 3: Yanıt Oluşturma ve Gönderme</h4><p>Yanıtı oluşturmak için önce <code>response.writeHead</code> metoduyla HTTP durum kodunu ve gerekirse başka başlıkları belirtiriz. Sonra <code>response.end</code> metoduyla istemciye gönderilecek içeriği ekleriz:</p><pre><code>response.writeHead(200, {'Content-Type': 'text/plain'});
response.end('Hello World');</code></pre><h4>Adım 4: Sunucuyu Dinlemeye Başlatma</h4><p>Sunucumuzun istekleri dinlemesi için bir port numarası belirleriz. Örneğin, 3000 numaralı portu kullanabiliriz:</p><pre><code>server.listen(3000, () =&gt; {
    console.log('Server running on port 3000');
});</code></pre><p>Bu adımlarla, basit bir Node.js web sunucusu oluşturmuş oluruz. Bu sunucu, belirtilen porta gelen isteklere 'Hello World' yanıtını döner.</p><h3><strong>İçerik Tipini Belirtmek</strong></h3><p>Yanıtın içerik tipini belirtmek, tarayıcının yanıtı doğru şekilde yorumlamasına yardımcı olur. Örneğin, düz metin için <code>Content-Type: text/plain</code> başlığını ekleyebiliriz.</p><h3><strong>Özet</strong></h3><p>Bu videoda öğrendiklerimiz:</p><ol><li><p>HTTP modülünü içe aktarma ve Node.js ile bir web sunucusu oluşturma.</p></li><li><p>Geri çağırma fonksiyonu ile istek ve yanıt nesnelerini kullanma.</p></li><li><p>Sunucuyu belirli bir porta dinlemeye başlatma ve basit bir yanıt döndürme.</p></li><li><p>Yanıtın içerik tipini belirtmenin önemi.</p></li></ol><p>Bu temel bilgilerle, Node.js'de basit bir web sunucusu oluşturabilir ve geliştirebilirsiniz. İlerleyen yazılarda istek ve yanıt nesnelerinin daha detaylı kullanımını inceleyeceğiz.</p>

Node Sunucusu Oluşturma

<h3><strong>HTTP Modülü Nedir ve Web Nasıl Çalışır?</strong></h3><p>Node.js'in HTTP modülüne geçmeden önce, web'in nasıl çalıştığını anlamak önemlidir. Web tarayıcınızda bir URL yazdığınızda neler olduğunu basitçe açıklayalım.</p><h4>İstemciler ve Sunucular</h4><p>İnternete bağlı bilgisayarlar "istemciler" ve "sunucular" olarak adlandırılır. İstemciler, bilgisayarlar ya da mobil telefonlar gibi internete bağlı cihazlardır ve bu cihazlarda bulunan web erişim yazılımları (örneğin bir web tarayıcı) ile web sitelerine erişirler. Sunucular ise, web sayfalarını, siteleri veya uygulamaları depolayan bilgisayarlardır.</p><img class="mx-auto" src="http://res.cloudinary.com/bg-forum/image/upload/v1701338001/bg-forum/tanxcjbuy8poek9hs7yl.png" alt="client server ilişkisi"><p>Bir URL yazdığınızda, istemci cihaz, web sayfasına erişim talep eder. Web sayfasının bir kopyası sunucudan indirilir ve istemciye, web tarayıcısında görüntülenecek şekilde yanıt olarak gönderilir. Bu model popüler olarak "istemci-sunucu modeli" olarak adlandırılır.</p><h4>Veri Transferi ve HTTP</h4><p>İstemci ve sunucu arasındaki veri transferi, hangi formatta yapılır? Eğer istemcinin gönderdiği istek sunucu tarafından anlaşılmazsa ya da sunucunun gönderdiği yanıt istemci tarafından anlaşılmazsa ne olur? İşte burada HTTP devreye girer. HTTP, "Hypertext Transfer Protocol" (Hipermetin Transfer Protokolü) anlamına gelir ve istemcilerle sunucuların birbirleriyle nasıl konuşacaklarını tanımlayan bir protokoldür. İstemci bir HTTP isteği gönderir ve sunucu bir HTTP yanıtı ile cevap verir. İşte web, yüksek seviyede bu şekilde çalışır.</p><h3><strong>Node.js ve HTTP</strong></h3><p>Peki, Node.js bu durumda nerede yer alıyor? Node.js, işletim sistemi işlevselliğine, örneğin ağ bağlantısına erişebilir ve asenkron görevleri çalıştıran bir olay döngüsüne sahip olduğu için, büyük hacimli istekleri aynı anda işleyebilen web sunucuları oluşturmak için mükemmeldir. Elbette, oluşturduğumuz Node sunucusu da HTTP formatına uymak zorundadır ve bunun için dahili HTTP modülünü kullanırız.</p><p>HTTP modülü, HTTP üzerinden veri transferi yapabilen web sunucuları oluşturmayı sağlar. Ve muhtemelen merakla beklediğiniz şey, Node.js kullanarak bir sunucu nasıl oluşturulur sorusudur. Bir sonraki videoda bu kodları inceleyeceğiz.</p><h3><strong>Özet</strong></h3><p>Bu makalede öğrendiklerimiz:</p><ol><li><p>İstemci-sunucu modeli ve web tarayıcılarındaki URL'lerin nasıl işlendiği.</p></li><li><p>İstemci ve sunucu arasındaki veri transferinin HTTP protokolü üzerinden nasıl gerçekleştiği.</p></li><li><p>Node.js'in, HTTP protokolünü kullanarak nasıl etkili bir şekilde web sunucuları oluşturabileceği.</p></li><li><p>HTTP modülünün, Node.js içinde nasıl kullanıldığı ve web sunucuları oluşturmanın temelleri.</p></li></ol>

Node.js HTTP Modülü

<p><span>Node.js'de pipes (borular), veri akışlarını daha etkin bir şekilde yönetmek için kullanılan bir özelliktir. Bu bölümde, pipes kullanımını ve </span><code>readableStream.on("data", callback)</code><span> ile </span><code>pipe()</code><span> metodunun kullanımı arasındaki farkları ele alacağız.</span></p><h3><strong>Pipes Kullanımı</strong></h3><p>Pipes, bir okunabilir akışı (readable stream) bir yazılabilir akışa (writable stream) bağlamak için kullanılır. Bu, okunabilir akıştan gelen veriyi doğrudan yazılabilir akışa aktarır. Örnek kullanım: <code>readableStream.pipe(writableStream)</code>. Pipes, veri akışını otomatik olarak yönetir ve bellek kullanımını optimize eder.</p><h3><code>readableStream.on("data", callback)</code><strong> Kullanımı</strong></h3><p>Bu yöntemde, <code>readableStream</code> üzerinde 'data' olayı için bir dinleyici tanımlarsınız. Her veri parçası geldiğinde, bu callback fonksiyonu çağrılır. Bu fonksiyon içinde, elde edilen veri parçası (<code>chunk</code>) işlenebilir ve gerektiğinde yazılabilir akışa manuel olarak yazılabilir:</p><pre><code>readableStream.on("data", (chunk) =&gt; {
  console.log(chunk);
  writableStream.write(chunk);
});</code></pre><h3><strong>Pipes ile </strong><code>readableStream.on("data", callback)</code> Arasındaki Farklar</h3><ol><li><p><strong>Otomatik Akış Yönetimi:</strong> Pipes, veri akışını otomatik olarak yönetir. <code>readableStream.on("data", callback)</code> yöntemi ise manuel akış kontrolü sağlar.</p></li><li><p><strong>Hafıza Yönetimi:</strong> Pipes, arka planda hafıza yönetimi yapar ve veri akışını belleğin kapasitesine göre ayarlar. Manuel yöntemde, bu tür bir hafıza yönetimi yapmak geliştiricinin sorumluluğundadır.</p></li><li><p><strong>Hata Yönetimi:</strong> Pipes kullanımında, hata yönetimi daha kolaydır. Akışlarda meydana gelen hatalar, zincirin sonunda yakalanabilir. Manuel yöntemde ise her adımda hata kontrolü yapmak gerekebilir.</p></li><li><p><strong>Zincirleme (Chaining):</strong> Pipes, zincirleme işlemlerine izin verir. Bu, akışları kolayca birbirine bağlamak ve karmaşık işlemleri basitleştirmek için kullanılır. Manuel yöntemde, bu tür bir zincirleme daha karmaşıktır.</p></li></ol><h3><strong>Örnek: Dosya Sıkıştırma</strong></h3><p>Pipes kullanarak <code>zlib</code> modülü ile dosya sıkıştırma işlemi yapılabilir:</p><pre><code>const gzip = zlib.createGzip();
readableStream.pipe(gzip).pipe(fs.createWriteStream('file2.txt.gz'));</code></pre><p>Bu örnekte, veri okunabilir akıştan gzip dönüştürücü akışına ve oradan yazılabilir akışa aktarılır.</p><h3><strong>Sonuç</strong></h3><p>Node.js'deki pipes, veri akışlarını yönetmek için güçlü ve esnek bir araçtır. Otomatik akış yönetimi, hafıza optimizasyonu ve hata yönetimi ile pipes, büyük veri setleri ve karmaşık akış işlemleri için idealdir. <code>readableStream.on("data", callback)</code> yöntemi ise daha düşük seviyeli bir kontrol sağlar ve özel durumlarda kullanışlı olabilir. Her iki yöntem de farklı ihtiyaçlara hizmet eder ve Node.js uygulamalarında verimli veri işleme için önemlidir.</p>

Node.js Pipes (Borular) ve Akış Yönetimi

<p>Node.js, genellikle büyük veri miktarlarını işlemek için kullanılan bir JavaScript çalışma zamanıdır. Bu makalede, Node.js'deki akışlar (streams) konseptini, özellikle de fs modülü üzerinden detaylıca ele alacağız.</p><h3><strong>Akışlar Nedir?</strong></h3><p>Akış, zaman içinde bir noktadan diğerine taşınan veri dizisidir. Örneğin, aynı bilgisayar içinde bir dosyadan diğerine veri aktarımı bir akış örneğidir. Akışların temel fikri, tüm verilerin bir anda kullanılabilir hale gelmesini beklemeden, verilerle parçalar halinde çalışmaktır. Dosya içeriğini bir dosyadan diğerine aktarırken, tüm içeriğin geçici bellekte saklanmasını beklemeden, içeriği zamanla parçalar halinde aktarırsınız. Bu, gereksiz bellek kullanımını önler.</p><h3><strong>Node.js'de Akışların Kullanımı</strong></h3><p>Node.js'de, akışlar genellikle doğrudan kullanılmaz; diğer modüller bu işlevselliği içsel olarak kullanır. Örneğin, fs modülü, dosya okuma ve yazma işlemleri için akışları kullanır. İki temel akış türü vardır: okunabilir akışlar (readable streams) ve yazılabilir akışlar (writable streams).</p><h4>Okunabilir Akışlar</h4><p>Okunabilir akışlar, verilerin parçalar halinde okunmasını sağlar. Örneğin, <code>fs.createReadStream</code> metodu, bir dosyadan veriyi parçalar halinde okumak için kullanılır. Okunabilir akışlar, 'data' olayı aracılığıyla veri parçalarını sağlar.</p><h4>Yazılabilir Akışlar</h4><p>Yazılabilir akışlar ise veriyi parçalar halinde yazmayı mümkün kılar. <code>fs.createWriteStream</code> metodu, bir dosyaya veriyi parçalar halinde yazmak için kullanılır.</p><h3><strong>Akışların Pratik Kullanımı</strong></h3><p>Bir dosyadan diğerine veri aktarmak için, önce okunabilir bir akış oluşturulur ve sonra bu veri yazılabilir bir akışa aktarılır. Bu işlem, <code>readableStream.on('data', callback)</code> ve <code>writableStream.write(chunk)</code> metotları ile gerçekleştirilir.</p><h3><strong>Akışların Avantajları</strong></h3><p>Akışlar, özellikle büyük dosyalarla çalışırken, bellek kullanımını optimize eder ve veri işleme sürecini hızlandırır. Akışlar, büyük veri kümelerini küçük, yönetilebilir parçalar halinde işleyerek, Node.js uygulamalarının verimliliğini artırır.</p><h3><strong>Özet</strong></h3><p>Bu makalede Node.js'de akışlar konseptini ele aldık:</p><ol><li><p>Akışlar, verileri zaman içinde parçalar halinde taşıyan veri dizileridir.</p></li><li><p>Node.js, okunabilir ve yazılabilir akışlar olmak üzere iki ana akış türünü destekler.</p></li><li><p><code>fs</code> modülü, dosyalardan okuma ve yazma işlemleri için akışları kullanır.</p></li><li><p>Akışlar, veri işleme sürecini hızlandırır ve bellek kullanımını optimize eder.</p></li><li><p>Node.js, veri yoğun uygulamalar için akışları etkili bir şekilde kullanır.</p></li></ol><p>Node.js'deki akışlar hakkında daha fazla bilgi edinmek ve pratik uygulamalar görmek için, Node.js belgelerini ve topluluk kaynaklarını incelemenizi öneririm.</p>

Node.js Streams (Akışlar)

<p>Node.js, dosya sistemiyle etkileşimde bulunmak için çeşitli modüller sunar. Bunlardan biri, önceki yazımızda ele aldığımız geleneksel <code>fs</code> modülüdür. Ancak, bu modülün daha modern ve gelişmiş bir versiyonu olan Promise tabanlı <code>fs</code> modülü, özellikle ES modülleri kullanıldığında daha yaygın olarak karşımıza çıkmaktadır. Bu yazıda, Promise tabanlı <code>fs</code> modülünün temel özelliklerini ve nasıl kullanılacağını anlatacağız.</p><h2><strong>fs Promise Modülünün İçeriği</strong></h2><p>Promise tabanlı <code>fs</code> modülü, asenkron programlama modelini benimser ve geleneksel callback yaklaşımına göre daha temiz ve okunabilir bir kod yazımı sağlar. İki adımda bu modülü kullanmayı göreceğiz:</p><h3><strong>Adım 1: Modülün İçe Aktarılması</strong></h3><p>Modülü projenize dahil etmek için aşağıdaki kodu kullanabilirsiniz:</p><p>const fs = require('node:fs/promises');</p><h3><strong>Adım 2: Dosya Okuma</strong></h3><p>Dosya okumak için <code>readFile</code> metodunu kullanacağız:</p><pre><code>fs.readFile('file.txt', 'utf-8')
  .then(data =&gt; console.log(data))
  .catch(error =&gt; console.log(error));</code></pre><p>Burada <code>readFile</code> metodu, bir Promise döndürür. İşlem başarılı olduğunda <code>then</code> bloğu, hata durumunda ise <code>catch</code> bloğu çalışır.</p><h2><strong>Async/Await ile Kullanım</strong></h2><p>Promise tabanlı <code>fs</code> modülü, <code>async/await</code> sözdizimi ile de kullanılabilir. Bunun için aşağıdaki gibi bir fonksiyon tanımlayabilirsiniz:</p><pre><code>async function readFileAsync() {
  try {
    const data = await fs.readFile('file.txt', 'utf-8');
    console.log(data);
  } catch (error) {
    console.log(error);
  }
}

readFileAsync();</code></pre><p>Bu yaklaşım, kodun daha okunabilir ve yönetilebilir olmasını sağlar.</p><h2><strong>Performans ve Tercih</strong></h2><p>Node.js'in Callback tabanlı <code>fs</code> modülü API'ları, performans açısından (hem yürütme süresi hem de bellek kullanımı bakımından) Promise tabanlı versiyondan daha üstün olabilir. Ancak, performans kritik bir faktör değilse, Promise tabanlı <code>fs</code> modülünü kullanmanızı öneririm.</p><h2><strong>Özet</strong></h2><p>Bu makalede, Node.js'in Promise tabanlı <code>fs</code> modülünün temel kullanımını ele aldık:</p><ol><li><p>Promise tabanlı <code>fs</code> modülü, ES modülleriyle daha yaygın kullanılan bir yaklaşımdır.</p></li><li><p>Modül, daha temiz ve okunabilir asenkron kod yazımı sağlar.</p></li><li><p><code>readFile</code> metodu ile dosya okuma işlemi yapılabilir.</p></li><li><p><code>async/await</code> ile kod daha anlaşılır hale getirilebilir.</p></li><li><p>Performans açısından, geleneksel Callback tabanlı <code>fs</code> modülü tercih edilebilir, ancak genel kullanım için Promise tabanlı modül yeterlidir.</p></li></ol>

fs Promise Modülü

<p>Node.js, dosya işlemlerini kolaylaştıran <code>fs</code> (File System) modülü ile donatılmıştır. Bu makalede, <code>fs</code> modülünü kullanarak dosya okuma ve yazma işlemlerini, hem senkron hem de asenkron olarak nasıl gerçekleştirebileceğimizi inceleyeceğiz.</p><h4>fs Modülünün Temelleri</h4><ul><li><p><strong>Modülün İçe Aktarılması</strong>: <code>fs</code> modülünü kullanmaya başlamak için, <code>require</code> fonksiyonu ile içe aktarmamız gerekmektedir: <code>const fs = require('node:fs');</code>.</p></li></ul><h4>Dosya Okuma İşlemleri</h4><ul><li><p><strong>Senkron Dosya Okuma</strong>: <code>readFileSync</code> metodu, belirtilen dosyayı senkron olarak okur. Bu işlem sırasında JavaScript motoru diğer işlemleri durdurur. Kullanımı:</p></li></ul><pre><code>// Senkron
const txtFile = fs.readFileSync("./file.txt", "utf-8");
console.log(txtFile.toString());</code></pre><p><strong>Asenkron Dosya Okuma</strong>: <code>readFile</code> metodu, dosya okuma işlemini asenkron olarak gerçekleştirir ve bir geri çağırma fonksiyonu alır. Bu sayede uygulamanın diğer işlemleri bloklanmaz:</p><pre><code>// Asenkron
fs.readFile("./file.txt", (err, data) =&gt; {
  if (err) {
    console.log("Dosya okunurken hata oluştu:", err);
  } else {
    console.log(data.toString());
  }
});</code></pre><h4>Dosya Yazma İşlemleri</h4><ul><li><p><strong>Senkron Dosya Yazma</strong>: <code>writeFileSync</code> metodu, dosyanın içeriğini belirtilen metinle senkron olarak değiştirir. Bu işlem sırasında diğer JavaScript işlemleri bekletilir:</p></li></ul><pre><code>// Dosya içi yazıyı senkron değiştirme
fs.writeFileSync("./file.txt", "Hello World!");</code></pre><p><strong>Asenkron Dosya Yazma</strong>: <code>writeFile</code> metodu, dosya yazma işlemini asenkron olarak gerçekleştirir. Bu metodun asenkron olması, uygulamanın diğer işlemlerinin bu süreçten etkilenmemesini sağlar:</p><pre><code>// Dosya içi yazıyı asenkron değiştirme
fs.writeFileSync("./file.txt", "Hello World!", (err) =&gt; {
  if (err) {
    console.log("Dosya yazılırken bir hata oluştu.", err);
  } else {
    console.log("Dosya başarıyla yazıldı!");
  }
});</code></pre><p><strong>Asenkron Append ile Dosya Yazma</strong>: <code>writeFile</code> metodu, <code>flag</code> seçeneği ile birlikte kullanıldığında, mevcut dosya içeriğinin sonuna yeni içerik ekleyebilir:</p><pre><code>// Dosya içi yazıyı asenkron append ile yazının sonuna istenilen yazıyı ekleme
fs.writeFile("./file.txt", "Hello World!", { flag: "a" }, (err) =&gt; {
  if (err) {
    console.log("Dosya yazılırken bir hata oluştu.", err);
  } else {
    console.log("Dosya başarıyla yazıldı!");
  }
});</code></pre><h4>Özet</h4><p>Bu makalede Node.js'in <code>fs</code> modülünü kullanarak dosya okuma ve yazma işlemlerinin nasıl yapıldığını gördük. Senkron ve asenkron metodlar, farklı senaryolara göre tercih edilebilir. Asenkron işlemler, uygulamanın performansını artırırken, senkron işlemler bazı durumlarda daha uygun olabilir.</p><h4>Öğrendiklerimiz</h4><ol><li><p><code>fs</code> modülünün Node.js'te nasıl kullanılacağı.</p></li><li><p>Dosya okuma ve yazma işlemlerinin senkron ve asenkron yolları.</p></li><li><p>Uygulamanın performansını etkileyebilecek senkron ve asenkron işlemlerin avantajları ve dezavantajları.</p></li><li><p>Pratik örneklerle <code>fs</code> modülünün kullanımı.</p></li></ol>

Node.js İle Dosya Sistemine Erişim: fs Modülü

<p><span>Node.js, JavaScript'in sunucu tarafındaki uygulamalarını destekleyen güçlü bir platformdur. Bu makalede, Node.js'de asenkron programlamayı ele alacağız ve JavaScript'in bu konudaki temel yapısını inceleyeceğiz.</span></p><h2><strong>JavaScript'in Temel Özellikleri</strong></h2><p>JavaScript, temel olarak senkron, bloklayıcı ve tek iş parçacıklı bir dil olarak tasarlanmıştır. Bu üç özellik, JavaScript'in çalışma şeklini önemli ölçüde etkiler:</p><ol><li><p><strong>Senkron:</strong> JavaScript kodu, yukarıdan aşağıya doğru, bir seferde bir satır işleyerek çalışır.</p></li><li><p><strong>Bloklayıcı:</strong> Bir işlem tamamlanmadan diğerine geçilmez. Bu, uzun süren işlemler sırasında, tarayıcının veya programın donmasına sebep olabilir.</p></li><li><p><strong>Tek İş Parçacıklı:</strong> JavaScript, varsayılan olarak tek bir iş parçacığı (single-thread) üzerinde çalışır ve aynı anda sadece bir görevi yerine getirebilir.</p></li></ol><h3><strong>Senkron Programlamanın Dezavantajları</strong></h3><p>Bu yapı, özellikle veri tabanından veri çekme veya uzun süren işlemleri gerçekleştirme gibi durumlarda, uygulamanın performansını olumsuz etkileyebilir. Örneğin, bir veri tabanı sorgusu yapılırken, sorgu tamamlanana kadar diğer kodların çalışması bloklanır.</p><h2><strong>Asenkron JavaScript'in Önemi</strong></h2><p>Asenkron JavaScript, bu sorunları çözmek için ortaya çıkmıştır. Asenkron programlama, aşağıdaki avantajları sağlar:</p><ol><li><p><strong>Blok Olmama:</strong> Uzun süren işlemler ana iş parçacığını bloklamaz, böylece program diğer görevleri yerine getirmeye devam edebilir.</p></li><li><p><strong>Verimlilik:</strong> Uygulama, bir işlem tamamlanırken diğer işlemleri de sürdürebilir, bu da kullanıcı deneyimini ve uygulama performansını artırır.</p></li></ol><h3><strong>Asenkron Programlama Nasıl Çalışır?</strong></h3><p>Asenkron JavaScript, tarayıcılar ve Node.js gibi dış kaynaklar tarafından sağlanan API'lar ve fonksiyonlarla mümkündür. Bu API'lar, belirli olaylar gerçekleştiğinde (örneğin, bir dosyanın okunması veya bir ağ isteğinin tamamlanması) fonksiyonların asenkron olarak çağrılmasını sağlar.</p><h2><strong>Node.js ve Asenkron Programlama</strong></h2><p>Node.js, asenkron programlamanın temel bir parçasıdır ve bu yaklaşım, Node.js'in dahili modüllerinde de sıkça görülür. Örneğin, <code>fs</code> (file system) modülü, dosya işlemlerini asenkron olarak gerçekleştirmek için çeşitli fonksiyonlar sunar.</p><h3><strong>Pratik Uygulamalar</strong></h3><ul><li><p><strong>Dosya İşlemleri:</strong> Dosya okuma/yazma işlemleri asenkron olarak gerçekleştirilebilir, böylece ana iş parçacığı diğer işlemlere devam edebilir.</p></li><li><p><strong>Veri Tabanı Sorguları:</strong> Veri tabanından veri çekme işlemleri asenkron olarak yapılabilir, bu da uygulamanın veri beklerken diğer işlemleri yapmasına olanak tanır.</p></li></ul><h2><strong>Sonuç</strong></h2><p>Asenkron JavaScript, Node.js'in güçlü yanlarından biridir ve modern web uygulamalarının performansını ve kullanıcı deneyimini önemli ölçüde iyileştiren bir yaklaşımdır. Bu yaklaşım, uygulamaları daha hızlı ve etkili hale getirirken, aynı zamanda kaynak kullanımını optimize eder. Node.js ve asenkron programlama, özellikle veri yoğun uygulamalar için idealdir.</p>

Asenkron JavaScript

<p><span>Node.js, JavaScript tabanlı bir sunucu taraflı platform olup, etkili ve esnek bir şekilde veri işleme kapasitesine sahiptir. Bu makalede, Node.js'in önemli konseptlerinden biri olan "akışlar" ve "tamponlar" üzerine odaklanacağız. Önceki yazımızda, binary veri, karakter setleri ve karakter kodlamaları gibi temel kavramları ele aldık. Bu bilgiler ışığında, akışlar ve tamponlar konusunu daha derinlemesine anlamaya çalışacağız.</span></p><h2><strong>Akışlar (Streams) Nedir?</strong></h2><p>Node.js'de bir akış, bir noktadan diğerine zaman içinde taşınan veri dizisidir. İnternet üzerinden bir bilgisayardan diğerine veya aynı bilgisayarda bir dosyadan diğerine aktarılan veri akışları buna örnek gösterilebilir. Node.js'deki temel fikir, tüm verinin elde edilmesini beklemek yerine, gelen veriyi parçalar halinde işlemektir. Örneğin, YouTube'da bir video izlerken, videonun tamamının indirilmesini beklemeyiz; veri parçalar halinde gelir ve biz de bu parçaları izleriz.</p><h3><strong>Akışların Avantajları</strong></h3><ol><li><p><strong>Verimlilik:</strong> Verileri parçalar halinde işlemek, gereksiz veri indirme ve bellek kullanımını önler.</p></li><li><p><strong>Hızlı Yanıt:</strong> Kullanıcıya, verinin tamamı gelmeden önce bir yanıt sunulabilir.</p></li></ol><h2><strong>Tamponlar (Buffers) Nedir?</strong></h2><p>Tampon, Node.js'de akış içindeki verilerin geçici olarak saklandığı yerdir. Veri akışının hızını kontrol edemeyiz, ancak verileri ne zaman işleyeceğimize karar verebiliriz. Bir lunaparktaki hız treni örneği ile açıklanacak olursa, trenin belirli bir kapasitesi vardır ve insanlar, trenin kalkış saatine bağlı olarak sıraya girerler. Tampon, bu bekleme alanına benzetilebilir.</p><h3><strong>Tamponların İşlevi</strong></h3><ol><li><p><strong>Veri Saklama:</strong> Tamponlar, işlenmeyi bekleyen verileri saklar.</p></li><li><p><strong>Veri Yönetimi:</strong> Veri akışının hızına bağlı olarak, tamponlar verileri uygun bir şekilde işlemek için kullanılır.</p></li></ol><h2><strong>Binary Veri ve Tamponlar Arasındaki İlişki</strong></h2><p>Node.js'teki tamponlar, binary verileri saklar. Örneğin, "Emin" kelimesi bir tampona kaydedildiğinde, bu kelimenin her karakterinin Unicode karakter kodu tampon içinde saklanır. Bu kodlar, binary olarak temsil edilir ve hexadecimal formatta gösterilir. Bu, binary veri ve karakter setlerinin temel anlayışının, tamponlarla nasıl ilişkili olduğunu gösterir.</p><h3><strong>Tamponlarla Çalışmak</strong></h3><p>Node.js'te tamponlarla çalışırken, bu tamponlara yazabilir ve tampon içindeki verileri okuyabiliriz. Ancak, tamponların sınırlı bir hafıza kapasitesi vardır ve bu kapasiteyi aşan veriler kaybolur.</p><h2><strong>Özet</strong></h2><p>Bu makalede ele aldığımız başlıca konular:</p><ol><li><p><strong>Akışlar ve Tamponlar:</strong> Node.js'de veri işlemenin temel yapı taşları.</p></li><li><p><strong>Veri İşleme:</strong> Verilerin tamamını beklemek yerine parça parça işlenmesi.</p></li><li><p><strong>Tamponların Rolü:</strong> Verileri geçici olarak saklamak.</p></li><li><p><strong>Binary Verilerin İşlenmesi:</strong> Tamponlar aracılığıyla karakter setleri ve binary verilerin nasıl işlendiği.</p></li></ol><p>Node.js, bu kavramları etkili bir şekilde kullanarak, veri yoğun uygulamalar için ideal bir platform haline gelmektedir.</p>

Node.js'de Akışlar (Streams) ve Tamponlar (Buffers)

<p><span>Node.js, modern web geliştirmede kritik bir role sahiptir ve bu makalede, Node.js'in karakter setleri ve kodlama ile ilgili yönlerine odaklanacağız. Bu konular, bilgisayarların nasıl veri depoladığı ve işlediği ile ilgili temel bilgileri içerir.</span></p><h2><strong>Karakter Setleri ve İkili (Binary) Veri</strong></h2><p>Bilgisayarlar veriyi ikili (binary) formatta, yani 0'lar ve 1'ler dizisi olarak saklar ve işler. Basit bir sayı olan 4'ün ikili karşılığı <code>100</code> olarak temsil edilir. Bu temsil, 2 tabanlı (binary) sayı sistemine dayanır.</p><p>Karakterlerin ikili formatta temsili ise daha karmaşıktır. Örneğin, 'V' harfinin bilgisayar tarafından nasıl temsil edildiğini düşünelim. Bilgisayar, önce 'V' karakterini temsil eden bir sayıya (bu durumda Unicode'da 86) dönüştürür ve ardından bu sayıyı ikili formata çevirir. Karakter setleri, bu karakter-sayı eşleşmelerini tanımlar. En yaygın iki karakter seti ASCII ve Unicode'dur.</p><h2><strong>Karakter Kodlaması</strong></h2><p>Karakter kodlaması, bir karakter setindeki bir sayının nasıl ikili veriye dönüştürüleceğini belirler. UTF-8, en yaygın kullanılan karakter kodlama sistemlerinden biridir. UTF-8, her karakteri temsil etmek için bir veya daha fazla byte (8 bit) kullanır. Örneğin, 'V' harfi (86) UTF-8'de <code>01010110</code> olarak kodlanır.</p><h2><strong>Uygulamalı Örnekler</strong></h2><p>Node.js'te karakter setleri ve kodlamayla çalışırken, bu temelleri göz önünde bulundurmak önemlidir. Dosya okuma-yazma işlemleri, ağ iletişimleri ve veritabanı etkileşimleri gibi durumlarda, doğru karakter seti ve kodlamayı kullanmak veri bütünlüğü ve uyumluluğu açısından kritiktir.</p><pre><code>// Node.js'te UTF-8 ile bir dosya okuma örneği
const fs = require('fs');

fs.readFile('dosya.txt', 'utf8', (hata, veri) =&gt; {
    if (hata) throw hata;
    console.log(veri);
});</code></pre><h2><strong>Özet</strong></h2><p>Bu makalede, Node.js ile karakter setleri ve kodlama konularına değindik:</p><ol><li><p>Bilgisayarlar verileri ikili formatta depolar ve işler.</p></li><li><p>Karakter setleri, karakterleri sayılarla eşleştirir; örneğin, Unicode ve ASCII.</p></li><li><p>Karakter kodlaması, bu sayıların ikili veriye nasıl dönüştürüleceğini belirler; örneğin, UTF-8.</p></li><li><p>Uygulamalı bir örnek olarak, Node.js'te UTF-8 kullanarak dosya okuma işlemi gerçekleştirdik.</p></li></ol><p>Bu bilgiler, veri işleme ve depolama konularında sağlam bir temel oluşturur ve Node.js'te daha ileri düzey konulara geçiş yaparken faydalı olacaktır.</p>

Karakter Setleri ve Encoding

<p>Node.js, JavaScript tabanlı, etkinlik odaklı bir platformdur ve bu platformda olaylar (events) merkezi bir rol oynar. Bu makalede, özel bir modül oluşturarak EventEmitter sınıfını nasıl genişleteceğimizi ele alacağız.</p><h3><strong>EventEmitter Genişletme</strong></h3><p>Node.js'in Events modülü, EventEmitter sınıfını döndürür. Bu sınıfın bir örneğini kullanarak, olayları yayabilir ve yayılan olaylara yanıt verebiliriz. Kendi modülümüzü oluşturarak, EventEmitter sınıfının üzerine inşa edebiliriz.</p><h4>Özel Bir Sınıf Oluşturmak</h4><p>Örneğin, bir <code>PizzaShop</code> sınıfı oluşturalım ve bu sınıfı EventEmitter'dan türetelim. Bunu yapmak için, öncelikle EventEmitter'ı içe aktaralım ve ardından <code>extends</code> anahtar kelimesini kullanarak PizzaShop sınıfını genişletelim.</p><pre><code>const EventEmitter = require('events');

class PizzaShop extends EventEmitter {
    constructor() {
        super();
        this.orderNumber = 0;
    }

    placeOrder(size, topping) {
        this.orderNumber++;
        this.emit('order', size, topping);
    }

    displayOrderNumber() {
        console.log(`Mevcut sipariş numarası: ${this.orderNumber}`);
    }
}</code></pre><h4>Olaylarla Çalışmak</h4><p><code>placeOrder</code> metodunda, bir olay yayıyoruz (<code>this.emit('order', size, topping)</code>). Bu, PizzaShop sınıfının bir EventEmitter gibi davranmasını sağlar.</p><h4>Olay Dinleyicilerini Eklemek</h4><p>Bu sınıfı kullanarak, örneğin <code>index.js</code> dosyasında olay dinleyicileri ekleyebiliriz.</p><pre><code>const PizzaShop = require('./PizzaShop');
const pizzaShop = new PizzaShop();

pizzaShop.on('order', (size, topping) =&gt; {
    console.log(`Sipariş alındı: ${size} pizza, ${topping} ile.`);
});

pizzaShop.placeOrder('büyük', 'mantar');
pizzaShop.displayOrderNumber();</code></pre><h4>Ek Modüllerle İş Birliği Yapmak</h4><p>Ayrıca, başka bir modül oluşturarak (örneğin, <code>DrinkMachine</code>) bu olaylara yanıt verebiliriz. Bu, modüller arasındaki sıkı bağlantıyı azaltarak, daha modüler ve bakımı kolay kod yazmamıza olanak tanır.</p><pre><code>// DrinkMachine.js
class DrinkMachine {
    serveDrink(size) {
        if (size === 'büyük') {
            console.log('Ücretsiz içecek servisi yapıldı.');
        }
    }
}

module.exports = DrinkMachine;</code></pre><p><span>Index.js'de bu modülü kullanarak, </span><code>order</code><span> olayına ek yanıtlar ekleyebiliriz:</span></p><pre><code>const DrinkMachine = require('./DrinkMachine');
const drinkMachine = new DrinkMachine();

pizzaShop.on('order', (size, topping) =&gt; {
    drinkMachine.serveDrink(size);
});</code></pre><h3><strong>Özet</strong></h3><p>Bu makalede, EventEmitter sınıfını genişleterek özel bir modül oluşturmanın temellerini ele aldık. Ana noktalar şunlardır:</p><ol><li><p>EventEmitter sınıfını genişleterek kendi özel modüllerimizi oluşturabiliriz.</p></li><li><p>Bu yaklaşım, event tabanlı mimariyi kullanarak modüler ve bakımı kolay uygulamalar geliştirmemize olanak tanır.</p></li><li><p>Kendi eventlerimizi yayabilir ve bu olaylara çeşitli şekillerde yanıt verebiliriz.</p></li></ol>

EventEmitter'ı ile Uygulama: EventEmitter'ı Genişletmek

<p><span>Node.js, sunucu tarafı uygulamalarını geliştirmek için kullanılan popüler bir JavaScript ortamıdır. Bu makalede, Node.js'in ikinci yerleşik modülü olan Olaylar (Events) Modülü üzerinde duracağız ve bu modülün nasıl kullanıldığını örneklerle açıklayacağız.</span></p><h3><strong>Olaylar Modülünün Temelleri</strong></h3><p>Node.js'te olaylar, uygulamada gerçekleşen eylemler veya olaylardır ve bu olaylara yanıt verebiliriz. Olaylar Modülü, kendi özel olaylarımızı oluşturmamıza ve bu olaylara engellemeyen bir şekilde yanıt vermeye olanak tanır.</p><h4>Olaylar Modülü ile Basit Bir Örnek</h4><p>Olaylar kavramı, yalnızca Node.js'e özgü değildir ve günlük hayatımızda da mevcuttur. Örneğin, bir pizza siparişi verme sürecini ele alalım:</p><ol><li><p>Sipariş verildiğinde (bu bir olaydır), pizza pişirme işlemi başlar.</p></li><li><p>Pizza pişirme işlemi, sipariş verme olayına bir yanıttır.</p></li></ol><p>Bu senaryoyu, Node.js'de Olaylar Modülünü kullanarak kodlayabiliriz. İlk adım olarak, bu modülü içe aktarırız:</p><pre><code>const EventEmitter = require('events');
const emitter = new EventEmitter();</code></pre><p><code>EventEmitter</code> sınıfı, olayları yaymak ve olaylara yanıt vermek için gerekli işlevselliği sağlar.</p><h4>Olay Yayma ve Dinleme</h4><p>Bir olayı yaymak için <code>emit</code> metodunu kullanırız. Örneğin, bir pizza siparişi olayını yayabiliriz:</p><pre><code>emitter.emit('orderPizza', 'large', 'mushroom');</code></pre><p><span>Bu olayı yakalamak ve yanıt vermek için </span><code>on</code><span> metodunu kullanırız. Bu, bir geri çağırma fonksiyonu alır:</span></p><pre><code>emitter.on('orderPizza', (size, topping) =&gt; {
    console.log(`Bir ${size} pizza ${topping} ile pişiriliyor.`);
});</code></pre><h4>Olayların Önemi ve Asenkron Davranış</h4><p>Olaylar, Node.js'de olay tabanlı programlamayı sağlar ve kodun engellenmeden çalışmasını mümkün kılar. Olay yayıldığında, olaya kayıtlı dinleyiciler (geri çağırma fonksiyonları) otomatik olarak çağrılır. Bu, Node.js'in asenkron doğasının bir parçasıdır ve uygulamanın engellenmesini önler.</p><h3><strong>Özet</strong></h3><p>Bu makalede, Node.js'in Olaylar Modülünü ve bu modülün nasıl kullanılacağını inceledik:</p><ol><li><p><code>events</code> modülü, Node.js'te olaylarla çalışmamızı sağlar.</p></li><li><p><code>EventEmitter</code> sınıfı, olayları yaymak ve olaylara yanıt vermek için kullanılır.</p></li><li><p>Olayları yaymak için <code>emit</code> metodunu, olayları dinlemek için <code>on</code> metodunu kullanırız.</p></li><li><p>Olaylar, Node.js uygulamalarında asenkron programlama ve engellenmeyen kod akışı sağlar.</p></li></ol><p>Olaylar Modülü, Node.js'in güçlü yönlerinden biridir ve etkili bir şekilde kullanıldığında, uygulamaların daha verimli ve hızlı çalışmasını sağlar.</p>

Node.js'de Olaylar (Events) Modülü

<p>Node.js, JavaScript temelli bir sunucu tarafı platformu olup, web uygulamalarının geliştirilmesinde önemli bir role sahiptir. Bu makalede, Node.js'de sıkça kullanılan geri çağırma (callback) deseninin temellerini ve uygulamalarını inceleyeceğiz.</p><h3><strong>Geri Çağırma Deseninin Temelleri</strong></h3><p>Node.js'de geri çağırma deseni, asenkron programlamada yaygın olarak kullanılır. JavaScript'te fonksiyonlar, birinci sınıf nesnelerdir, yani bir fonksiyon başka bir fonksiyona argüman olarak geçirilebilir ya da bir fonksiyondan değer olarak dönebilir.</p><p><span>Bu kavramı anlamak için basit bir örnek üzerinden gidelim:</span></p><pre><code>function hello(name) {
    console.log(`Hello, ${name}`);
}

function helloName(helloFn) {
    const name = 'Emin';
    helloFn(name);
}

helloName(hello);</code></pre><p>Yukarıdaki örnekte, <code>helloName</code>fonksiyonu, başka bir fonksiyonu (<code>hello</code>) argüman olarak alıp çağırır. Burada <code>hello</code> fonksiyonu bir geri çağırma fonksiyonu olup <code>helloName</code>ise bir yüksek mertebe fonksiyondur.</p><h3><strong>Senkron ve Asenkron Geri Çağırma</strong></h3><p>Geri çağırma fonksiyonları iki ana kategoriye ayrılır: senkron ve asenkron.</p><ol><li><p><strong>Senkron Geri Çağırma:</strong> Bu tip geri çağırma, yüksek mertebe fonksiyon içinde hemen çalıştırılır. Örneğin, <code>Array</code> metodlarında kullanılan geri çağırma fonksiyonları (<code>map</code>, <code>filter</code>, <code>sort</code> gibi) senkron geri çağırma örnekleridir.</p></li><li><p><strong>Asenkron Geri Çağırma:</strong> Asenkron operasyonlar tamamlandıktan sonra kodun devam etmesi ya da resume edilmesi için kullanılır. Node.js'de dosya okuma, veritabanı sorguları ve ağ istekleri gibi işlemler genellikle asenkron gerçekleştirilir.</p></li></ol><h4>Asenkron Geri Çağırmanın Önemi</h4><p>Node.js'in asenkron yapısı, uygulamanın engellenmesini önler. Örneğin, dosya okuma işlemi ya da ağ isteği gerçekleştirilirken, bu işlemler tamamlanana kadar Node.js uygulamasının diğer bölümleri engellenmez. Böylece, uygulamanın performansı ve yanıt süresi artar.</p><h3><strong>Özet</strong></h3><p>Node.js'de geri çağırma deseni, platformun temel özelliklerinden biridir ve asenkron programlamanın anlaşılmasında kritik bir rol oynar. Özetle:</p><ol><li><p>JavaScript'te fonksiyonlar birinci sınıf nesnelerdir ve diğer fonksiyonlara argüman olarak geçilebilirler.</p></li><li><p>Geri çağırma fonksiyonları, başka bir fonksiyona argüman olarak geçirilen fonksiyonlardır.</p></li><li><p>Geri çağırma fonksiyonları senkron ve asenkron olmak üzere ikiye ayrılır.</p></li><li><p>Asenkron geri çağırma, Node.js'in asenkron doğasında önemli bir rol oynar ve uygulamanın engellenmesini önler.</p></li></ol><p>Geri çağırma deseni, Node.js programlamada performans ve verimliliği artıran önemli bir konsepttir. Bu desenin etkin kullanımı, uygulamaların daha hızlı ve etkili olmasını sağlar.</p>

Node.js'de Geri Çağırma (Callback) Pattern

<p><span>Bu bölümde, Node.js'deki </span><code>path</code><span> modülünü daha ayrıntılı bir şekilde inceliyoruz. </span><code>path</code><span> modülü, dosya ve dizin yollarıyla çalışırken ihtiyaç duyulan araçları sağlar.</span></p><h2><strong>Path Modülünü İçeri Aktarmak</strong></h2><p>Path modülünü kullanabilmek için öncelikle içeri aktarmamız gerekiyor. Bu, <code>require</code> fonksiyonu ile yapılır:</p><pre><code>const path = require('path');</code></pre><p><code>path</code> modülü, Node.js'in yerleşik bir modülü olduğu için, modülün adı direkt olarak <code>require</code> fonksiyonuna argüman olarak verilir.</p><h2><strong>Path Modülünün Temel Özellikleri</strong></h2><p><code>path</code> modülü, çeşitli özellikler ve metodlar içerir. Bu metodlardan bazıları şunlardır:</p><h3><strong>1. </strong><code>basename</code> Metodu</h3><p>Bu metod, verilen yolun son bölümünü (dosya veya dizin adı) döndürür.</p><pre><code>console.log(path.basename(__filename)); // index.js
console.log(path.basename(__dirname));  // node.js</code></pre><h3><strong>2. </strong><code>extname</code> Metodu</h3><p>Bu metod, yolun uzantısını döndürür.</p><pre><code>console.log(path.extname(__filename)); // .js</code></pre><h3><strong>3. </strong><code>parse</code> Metodu</h3><p>Bu metod, yolun ayrıntılı parçalarını içeren bir nesne döndürür.</p><pre><code>let parsedPath = path.parse(__filename);
console.log(parsedPath);</code></pre><h3><strong>4. </strong><code>format</code> Metodu</h3><p>Bu metod, <code>parse</code> metoduyla elde edilen nesneyi tekrar bir yol stringine dönüştürür.</p><pre><code>console.log(path.format(parsedPath)); // __filename ile aynı yol</code></pre><h3><strong>5. </strong><code>isAbsolute</code> Metodu</h3><p>Bu metod, yolun mutlak (absolute) olup olmadığını kontrol eder.</p><pre><code>console.log(path.isAbsolute(__filename)); // true
console.log(path.isAbsolute('./data.json')); // false</code></pre><h3><strong>6. </strong><code>join</code> Metodu</h3><p>Bu metod, verilen yol segmentlerini birleştirir ve normalize eder.</p><pre><code>console.log(path.join('folder1', 'folder2', 'index.html')); // 'folder1/folder2/index.html'</code></pre><h3><strong>7. </strong><code>resolve</code> Metodu</h3><p>Bu metod, verilen yol segmentlerini birleştirerek mutlak bir yol oluşturur.</p><pre><code>console.log(path.resolve('folder1', 'folder2', 'index.html')); // Mutlak yol</code></pre><h2><strong>Özet</strong></h2><p><code>path</code> modülü, Node.js uygulamalarında dosya ve dizin yollarıyla çalışırken oldukça kullanışlıdır. Bu modül, yol bilgilerini analiz etmek, yol segmentlerini birleştirmek ve normalize etmek gibi çeşitli işlevleri sağlar. Bu işlevler, dosya işlemleri ve yol yönetimi söz konusu olduğunda geliştiricilere büyük kolaylıklar sunar.</p>

Node.js Path Modülü

<p><span>Node.js'in güçlü yönlerinden biri, geliştirme sürecini kolaylaştıran yerleşik (built-in) modüllerin geniş yelpazesidir. Bu yazıda, Node.js'in yerleşik modüllerine odaklanacağız.</span></p><h2><strong>Yerleşik Modüller Nedir?</strong></h2><p>Yerleşik modüller, Node.js ile birlikte gelen ve 'çekirdek modüller' olarak da adlandırılan modüllerdir. Bu modüller, Node.js'i yüklediğinizde varsayılan olarak kullanılabilir durumdadır. Ancak, bu modülleri kullanmadan önce projenize içe aktarmanız (import etmeniz) gerekmektedir.</p><p>Node.js, bir dizi yerleşik modülle birlikte gelir, ancak bu yazıda beş temel modül üzerinde duracağız: <code>path</code>, <code>events</code>, <code>fs</code>, <code>stream</code>, ve <code>http</code>.</p><h3><strong>1. Path Modülü</strong></h3><p><code>path</code> modülü, dosya ve dizin yolları ile ilgili işlemler yapmanıza olanak tanır. Bu modül, platformlar arası uyumluluk sağlayarak, farklı işletim sistemlerindeki yol ayrımlarını yönetmenize yardımcı olur. Örnek kullanımı:</p><pre><code>const path = require('path');

let dosyaYolu = path.join('/kullanici', 'dosyalar', 'dosya.txt');
console.log(dosyaYolu); // '/kullanici/dosyalar/dosya.txt' veya Windows'ta '\\kullanici\\dosyalar\\dosya.txt'</code></pre><h3><strong>2. Events Modülü</strong></h3><p><code>events</code> modülü, olay tabanlı programlamayı destekler. Bu modül, Node.js'in asenkron doğasının temel taşlarından biridir. Özellikle, olay dinleyicileri (listeners) ve olay yayıcıları (emitters) ile çalışır.</p><h3><strong>3. FS Modülü</strong></h3><p><code>fs</code> modülü, dosya sistemi ile ilgili işlemleri gerçekleştirmek için kullanılır. Bu modül, dosya okuma, yazma, silme ve daha birçok dosya sistemi işlemini gerçekleştirmenize olanak tanır.</p><h3><strong>4. Stream Modülü</strong></h3><p><code>stream</code> modülü, Node.js'teki veri akışlarını işlemek için kullanılır. Büyük veri dosyalarını parça parça işlemek veya ağ üzerinden veri aktarımı yaparken bu modül oldukça kullanışlıdır.</p><h3><strong>5. HTTP Modülü</strong></h3><p><code>http</code> modülü, HTTP sunucuları oluşturmak ve istemci istekleri yapmak için kullanılır. Bu modül, Node.js'in web uygulamaları geliştirme kapasitesinin temelini oluşturur.</p><h2><strong>Özet</strong></h2><p>Yerleşik modüller, Node.js'in etkili ve esnek yapısının bir parçasıdır. Bu modüller, geliştiricilere bir dizi temel işlevsellik sağlayarak, dosya işlemleri, olay yönetimi, veri akışı ve HTTP işlemleri gibi konularda kolaylık sunar. Bu beş temel modül, Node.js uygulamaları geliştirirken sıkça kullanılan yapı taşlarındandır.</p>

Built-in Modules: Yerleşik Modüller

<p><span>Node.js'de yerel modüllerle ilgili bu bölümde, JSON veri içeri aktarımını ve Node.js'in izleme modunu inceleyeceğiz.</span></p><h2><strong>JSON Verilerini İçeri Aktarmak</strong></h2><p>JSON, JavaScript Object Notation'ın kısaltmasıdır ve web sunucuları ile sıkça kullanılan bir veri alışverişi formatıdır. Node.js'de, <code>.json</code> uzantılı bir dosyayı bir modül gibi içe aktarabiliriz. Bunun için <code>require</code> fonksiyonunu kullanırız. Örneğin, <code>data.json</code> adında bir dosya oluşturup içine bir JavaScript nesnesi yerleştirebilir ve sonra bu dosyayı içeri aktarabiliriz:</p><pre><code>// data.json
{
  "name": "Emin Başbayan",
  "address": {
    "country": "Turkey",
    "city": "İstanbul"
  }
}

// index.js
const data = require('./data.json');
console.log(data); // JSON verisi bir JavaScript nesnesi olarak gösterilir</code></pre><p>JSON verileri, Node.js tarafından otomatik olarak bir JavaScript nesnesine dönüştürülür. JSON dosyalarını içe aktarırken <code>.json</code> uzantısını belirtmek zorunda değilsiniz, ancak aynı adla bir <code>.js</code> dosyası varsa, Node.js önce <code>.js</code> dosyasını arayacaktır. Bu nedenle, hataları önlemek için uzantıyı belirtmek genellikle daha iyidir.</p><h2><strong>Node.js'de Gözetleme Modu</strong></h2><p>Node.js 18 sürümü ile tanıtılan bir diğer önemli özellik ise 'watch mode' veya 'gözetleme modu'dur. Bu mod, kodunuzda bir değişiklik yapıldığında Node.js sürecini otomatik olarak yeniden başlatır. Bu, özellikle sürekli olarak kod değişiklikleri yapıp çıktıyı kontrol etmeniz gereken durumlarda oldukça kullanışlıdır.</p><p>Gözetleme modunu kullanmak için terminalde aşağıdaki komutu çalıştırabilirsiniz:</p><pre><code>node --watch index.js</code></pre><p>Bu komut çalıştırıldığında, <code>index.js</code> dosyasında herhangi bir değişiklik yapıldığında, Node.js bu dosyayı otomatik olarak yeniden çalıştırır ve güncellenmiş çıktıyı terminalde gösterir.</p>

JSON Veri İçeri Aktarma ve Watch Modu

<p>Node.js'de geleneksel olarak CommonJS modül formatı kullanılmıştır. Ancak, ES2015 (ECMAScript 2015) ile JavaScript diline resmi bir modül sistemi eklenmiştir: ES Modülleri. Bu makalede, Node.js'de ES Modüllerinin nasıl kullanıldığını ve CommonJS ile arasındaki farkları ele alacağız.</p><h2><strong>ES Modülleri Nedir?</strong></h2><p>ES Modülleri, JavaScript'in standart modül sistemidir. Bu sistem, modül tanımlamalarını ve içe aktarmalarını <code>export</code> ve <code>import</code> anahtar kelimeleri ile yapar. ES Modülleri, kodun daha düzenli ve modüler bir şekilde organize edilmesini sağlar.</p><h2><strong>ES Modülleri ile Çalışmak</strong></h2><p>ES Modüllerinde dosya uzantısı olarak <code>.mjs</code> kullanılır. İşte bazı temel kullanım örnekleri:</p><h3><strong>Tek Değişken veya Fonksiyon Dışa Aktarma (Default Export)</strong></h3><pre><code>// math-esm.mjs
export default function add(a, b) {
    return a + b;
}

// main.mjs
import add from './math-esm.mjs';
console.log(add(5, 5)); // 10</code></pre><h3><strong>Birden Fazla Değişken veya Fonksiyon Dışa Aktarma (Named Export)</strong></h3><pre><code>// math-esm.mjs
export const add = (a, b) =&gt; a + b;
export const subtract = (a, b) =&gt; a - b;

// main.mjs - Tüm İçe Aktarımları Bir Objede Toplama
import * as math from './math-esm.mjs';
console.log(math.add(5, 5)); // 10
console.log(math.subtract(5, 5)); // 0

// main.mjs - Belirli İçe Aktarımları Seçme
import { add, subtract } from './math-esm.mjs';
console.log(add(5, 5)); // 10
console.log(subtract(5, 5)); // 0</code></pre><h3><strong>Destructuring ile İçe Aktarma</strong></h3><p>ES Modüllerinde de destructuring kullanarak sadece ihtiyaç duyulan fonksiyonları veya değişkenleri içe aktarabiliriz.</p><h2><strong>ES Modülleri ve CommonJS Arasındaki Farklar</strong></h2><ul><li><p><strong>Dosya Uzantısı:</strong> ES Modülleri için <code>.mjs</code>, CommonJS için <code>.js</code> kullanılır.</p></li><li><p><strong>Dışa Aktarma:</strong> ES Modülleri <code>export</code> anahtar kelimesini kullanırken, CommonJS <code>module.exports</code> kullanır.</p></li><li><p><strong>İçe Aktarma:</strong> ES Modülleri <code>import</code> anahtar kelimesini, CommonJS <code>require()</code> fonksiyonunu kullanır.</p></li></ul><h2><strong>Sonuç</strong></h2><p>ES Modülleri, Node.js ve modern JavaScript uygulamalarında giderek daha fazla kullanılmaktadır. Bu modül sistemi, JavaScript'in standartlarla uyumlu, daha modüler ve temiz kod yazımını destekler. Ancak, mevcut projelerde hâlâ yaygın olarak CommonJS kullanılmaktadır. Node.js geliştiricileri için her iki modül sistemini de anlamak önemlidir. Bu makalede ES Modülleri'nin temel kullanım örneklerini ve CommonJS ile olan farklarını inceledik. Bu bilgiler, Node.js'de daha etkili modül yönetimi ve kod organizasyonu için önemlidir.</p>

Node.js'de ES Modülleri

<h2><strong>Giriş</strong></h2><p>Node.js'de modül dışa aktarma işlemlerinde <code>module.exports</code> ve <code>exports</code> sıkça kullanılır. Bu iki terim birbirine benzer görünse de aralarında önemli farklar bulunmaktadır. Bu makalede, bu iki yaklaşım arasındaki temel farkları ve kullanım senaryolarını inceleyeceğiz.</p><h2><code>module.exports</code><strong> ve </strong><code>exports</code> Arasındaki İlişki</h2><p>Node.js modüllerinde <code>exports</code>, <code>module.exports</code>'un başlangıçta bir referansıdır. Yani, <code>exports</code> başlangıçta <code>module.exports</code> ile aynı nesneyi gösterir. Ancak bu referans ilişkisi, <code>exports</code>'a yeni bir değer atandığında bozulur.</p><h2><code>exports</code><strong> Kullanımının Limitasyonları</strong></h2><p><code>exports</code> kullanırken, sadece mevcut nesneye özellik ekleyebilirsiniz. Eğer <code>exports</code>'a yeni bir değer atarsanız, bu <code>module.exports</code> ile olan referans bağını koparır ve beklenmeyen sonuçlara yol açabilir. Bu durumu JavaScript'teki nesne referansları ile açıklamak mümkündür:</p><pre><code>let obj1 = { name: "Bruce Wayne" };
let obj2 = obj1;
obj2.name = "Clark Kent";
console.log(obj1.name); // "Clark Kent"

obj2 = { name: "Clark Kent" };
console.log(obj1.name); // "Bruce Wayne"</code></pre><p>Bu örnekte, <code>obj2</code>'ye yeni bir nesne atandığında, <code>obj1</code> ile olan referans bağı kopar ve <code>obj1</code> değişmez.</p><h2><code>module.exports</code><strong>'un Güvenilirliği</strong></h2><p><code>module.exports</code> kullanarak bir modül dışa aktarıldığında, modülün dışa aktarılacak içeriği net bir şekilde tanımlanır. <code>module.exports</code>'a atama yapmak, bu nesnenin tamamını değiştirir ve herhangi bir referans ilişkisi bozulmaz. Bu, özellikle modülün tamamını tek bir değerle dışa aktarmak istediğinizde faydalıdır.</p><h2><strong>Örnek Senaryolar</strong></h2><ul><li><p><strong>Tek Bir Fonksiyon Dışa Aktarmak:</strong> <code>module.exports = function() {...};</code></p></li><li><p><strong>Birden Fazla Fonksiyon veya Nesne Dışa Aktarmak:</strong> <code>exports.add = function() {...}; exports.subtract = function() {...};</code></p></li></ul><h2><strong>Sonuç</strong></h2><p><code>module.exports</code> ve <code>exports</code> arasındaki temel fark, <code>exports</code>'un <code>module.exports</code> ile olan referans ilişkisidir. <code>exports</code>'a yeni bir değer atamak bu ilişkiyi bozar ve <code>module.exports</code> ile olan bağı koparır. <code>module.exports</code>, modül dışa aktarmada daha esnek ve güvenilir bir yöntemdir ve genellikle tercih edilir. Modül dışa aktarma işlemlerinde bu farkın bilinmesi, beklenmeyen hataların önlenmesi açısından önemlidir. Bu makalede, <code>module.exports</code> ve <code>exports</code> arasındaki farkları ve ne zaman hangisinin kullanılması gerektiğini ele aldık. Bu bilgiler, Node.js modüllerinin doğru şekilde yönetilmesi ve hata riskinin azaltılması için önemlidir.</p>

Node.js'de module.exports ve exports Arasındaki Farklar

<h2><strong>Giriş</strong></h2><p>Node.js uygulamalarında modüllerin içe ve dışa aktarılması, kod organizasyonu ve yeniden kullanılabilirlik açısından önemlidir. Bu makalede, Node.js'de karşılaşabileceğiniz farklı içe ve dışa aktarma desenlerini ele alacağız.</p><h2><strong>1. Desen: Tek Değişken veya Fonksiyon Dışa Aktarma</strong></h2><p>Bu desende, tek bir değişken veya fonksiyon <code>module.exports</code> aracılığıyla dışa aktarılır. Örneğin, <code>math.js</code> içinde bir <code>add</code> fonksiyonu tanımlayıp, bu fonksiyonu dışa aktarabiliriz:</p><pre><code>// math.js
function add(a, b) {
    return a + b;
}
module.exports = add;

// index.js
const add = require('./math');
console.log(add(2, 3)); // 5</code></pre><h2><strong>2. Desen: Fonksiyonu Direkt </strong><code>module.exports</code> Olarak Tanımlama</h2><p>Bu desende, fonksiyon doğrudan <code>module.exports</code> olarak tanımlanır. Bu, bir önceki desenin daha kısa bir versiyonudur:</p><pre><code>// math.js
module.exports = function add(a, b) {
    return a + b;
};

// index.js aynı kalır</code></pre><h2><strong>3. Desen: Birden Fazla Değişken veya Fonksiyon Dışa Aktarma</strong></h2><p>Birden fazla değişken veya fonksiyon dışa aktarmak için bir nesne kullanılır. Bu nesne, dışa aktarılacak öğeleri içerir:</p><pre><code>// math.js
function add(a, b) {
    return a + b;
}
function subtract(a, b) {
    return a - b;
}
module.exports = { add, subtract };

// index.js
const math = require('./math');
console.log(math.add(2, 3)); // 5
console.log(math.subtract(2, 3)); // -1</code></pre><h2><strong>4. Desen: Fonksiyonları Direkt </strong><code>module.exports</code> Nesnesine Tanımlama</h2><p>Her fonksiyon, <code>module.exports</code> nesnesine doğrudan atanır. Bu, üçüncü desenin alternatif bir yaklaşımıdır:</p><pre><code>// math.js
module.exports.add = function add(a, b) {
    return a + b;
};
module.exports.subtract = function subtract(a, b) {
    return a - b;
};

// index.js aynı kalır</code></pre><h2><strong>5. Desen: </strong><code>exports</code> Kullanımı</h2><p><code>exports</code> değişkeni, <code>module.exports</code>'a kısayol olarak kullanılır. Ancak bu kullanım, bazı durumlarda kafa karışıklığına yol açabilir:</p><pre><code>// math.js
exports.add = function add(a, b) {
    return a + b;
};
exports.subtract = function subtract(a, b) {
    return a - b;
};

// index.js aynı kalır</code></pre><p><span>Bu desenler, Node.js'de modüllerin içe ve dışa aktarılmasında sıklıkla karşılaşılan yöntemlerdir. Her bir desen, belirli ihtiyaç ve tercihlere göre kullanılabilir. Ancak, modüllerin nasıl içe ve dışa aktarıldığını anlamak, kodun bakımı ve yönetimi açısından kritik öneme sahiptir. Bu makalede bu beş farklı deseni ve kullanımlarını ele aldık. Bu desenlerin anlaşılması, Node.js uygulamalarının geliştirilmesinde etkin bir rol oynar.</span></p>

Node.js'de Modül İçe ve Dışa Aktarma Desenleri: Import Export Patterns

<h2><strong>Giriş</strong></h2><p>Node.js uygulamalarında performans ve verimlilik açısından önemli bir konu olan modül önbelleğe alma (module caching) konseptini bu makalede ele alacağız. Özellikle, modüllerin nasıl önbelleğe alındığını ve bu özelliğin uygulamalara nasıl etki ettiğini inceleyeceğiz.</p><h2><strong>Modül Önbelleğe Alma Nedir?</strong></h2><p>Node.js'de bir modül ilk kez <code>require</code> ile çağrıldığında, modülün içeriği yüklenir ve önbelleğe alınır. Bu, modül tekrar çağrıldığında, Node.js'in daha önce önbelleğe alınan sürümü kullanmasını sağlar. Bu durum, modülün her seferinde yeniden yüklenmesini engeller, böylece performansı artırır.</p><h2><strong>Önbelleğe Alma Nasıl Çalışır?</strong></h2><p>Örneğin, <code>super-hero.js</code> adında bir modül oluşturup, bu modülde bir sınıf tanımlayıp, bu sınıfın bir örneğini dışa aktaralım. <code>index.js</code> dosyasında bu modülü <code>require</code> ile içe aktardığımızda ve modülün bir özelliğini değiştirdiğimizde, bu değişiklik modülün önbelleğe alınmış sürümünde de yansır.</p><pre><code>// super-hero.js
class SuperHero {
    constructor(name) {
        this.name = name;
    }
    getName() {
        return this.name;
    }
    setName(name) {
        this.name = name;
    }
}
module.exports = new SuperHero("Batman");

// index.js
const superHero = require('./super-hero');
console.log(superHero.getName()); // Batman
superhero.setName("Superman");
console.log(superHero.getName()); // Superman

const newSuperHero = require('./super-hero');
console.log(newSuperHero.getName()); // Superman</code></pre><p>Bu örnekte, <code>super-hero</code> modülünün <code>name</code> özelliği "Batman" olarak başlar, daha sonra "Superman" olarak değiştirilir. <code>newSuperHero</code> ile modülü yeniden içe aktardığımızda, değiştirilmiş "Superman" ismini alırız. Bu, modülün önbelleğe alındığının ve aynı örneğin kullanıldığının bir göstergesidir.</p><h2><strong>Önbelleğe Almanın Etkileri ve Yönetimi</strong></h2><p>Modül önbelleğe alma, performans açısından yararlı olsa da, bazı durumlarda farklı modül örnekleri oluşturmak isteyebiliriz. Bunu başarmak için, sınıfı doğrudan dışa aktarabilir ve her <code>require</code> çağrısında yeni bir örnek oluşturabiliriz.</p><pre><code>// superhero.js güncellenmiş versiyonu
module.exports = SuperHero;

// index.js güncellenmiş versiyonu
const SuperHero = require('./super-hero');
const batman = new SuperHero("Batman");
const superman = new SuperHero("Superman");</code></pre><p>Bu yaklaşımla, her <code>new SuperHero()</code> çağrısında yeni bir örnek oluştururuz, böylece her biri bağımsız olarak yönetilebilir.</p><h2><strong>Özet</strong></h2><ul><li><p>Node.js'de modüller, ilk yüklenmelerinde önbelleğe alınır. Bu, modülün yeniden kullanılmasını kolaylaştırır ve performansı artırır.</p></li><li><p>Modül önbelleğe alma, aynı modülün farklı örneklerinin ihtiyaç duyulduğu durumlarda yönetilmesi gereken bir durumdur.</p></li><li><p>Farklı modül örnekleri oluşturmak istendiğinde, sınıfı veya fonksiyonu dışa aktarıp her seferinde yeni bir örnek oluşturmak mümkündür.</p></li><li><p>Modül önbelleğe almanın doğru kullanımı, Node.js uygulamalarının performansını ve esnekliğini artırır.</p></li></ul><p>Bu makalede, Node.js'de modül önbelleğe almanın nasıl çalıştığı ve uygulamalar üzerindeki etkileri hakkında temel bilgileri ele aldık. Bu konseptin anlaşılması, Node.js uygulamalarını daha etkin bir şekilde geliştirmek için önemlidir.</p>

Node.js'de Modül Önbelleğe Alma (Module Caching)

<h2><strong>Giriş</strong></h2><p>Node.js, modüllerin işlevselliği ve kapsamını yönetmek için özel bir yapı kullanır: Modül Sarıcı (Module Wrapper). Bu makalede, Node.js'deki modül sarıcısının nasıl çalıştığını ve modül içindeki değişkenlerin kapsamını nasıl etkilediğini inceleyeceğiz.</p><h2><strong>Modül Sarıcının Temelleri</strong></h2><p>Node.js'de her modül, yüklenmeden önce bir IIFE (Immediately Invoked Function Expression) içinde sarılır. Bu yapı, modül seviyesindeki değişkenleri global nesneden izole eder. Modül sarıcısı, modülün işlevselliği için önemli olan beş parametre içerir: <code>exports</code>, <code>require</code>, <code>module</code>, <code>__filename</code>, <code>__dirname</code>.</p><h2><strong>IIFE ve Parametreler</strong></h2><p>Basit bir IIFE örneği üzerinden parametre ve argümanların nasıl kullanıldığını anlamak yararlıdır. Örneğin, iki IIFE içinde <code>message</code> parametresi tanımlayıp, bu parametreye farklı argümanlar geçirebiliriz. Bu, Node.js modüllerindeki sarıcı işlevinin bir benzeridir.</p><pre><code>// IIFE örneği
(function(message) {
    console.log(message + " Batman");
})("Hello");

(function(message) {
    console.log(message + " Superman");
})("Hey");</code></pre><h2><strong>Node.js Modül Sarıcısının Anlaşılması</strong></h2><p>Node.js modül sarıcısı, her modülü aşağıdaki gibi bir IIFE içine alır:</p><pre><code>(function(exports, require, module, __filename, __dirname) {
    // Modül kodu burada yer alır
});</code></pre><p>Bu parametrelerin her biri, modülün işlevselliği için önemlidir:</p><ul><li><p><code>exports</code>: Modülün dışa aktardığı öğeleri tanımlar.</p></li><li><p><code>require</code>: Diğer modülleri yüklemek için kullanılır.</p></li><li><p><code>module</code>: Mevcut modülle ilgili bilgileri içerir.</p></li><li><p><code>__filename</code>: Modülün dosya yolunu verir.</p></li><li><p><code>__dirname</code>: Modülün bulunduğu dizinin yolunu verir.</p></li></ul><h2><strong>Uygulama ve Örnekler</strong></h2><p>Bu yapı, <code>require</code> ve <code>module.exports</code> gibi görünüşte global ama aslında her modüle özgü değişkenlere erişim sağlar. Bu değişkenler, Node.js tarafından her modülün yürütülmesi sırasında enjekte edilir.</p><p>Örnek olarak, <code>index.js</code> dosyasında bir hata ayıklama noktası belirleyip, yerel değişkenler panelinden bu parametreleri gözlemleyebiliriz. Her modül için <code>__filename</code> ve <code>__dirname</code> değişkenlerinin değerleri değişir, bu da modülün dosya ve dizin yollarını temsil eder.</p><h2><strong>Özet</strong></h2><ul><li><p>Node.js, her modülü özel bir IIFE içinde sarar. Bu, modül seviyesindeki değişkenlerin ve fonksiyonların global kapsamdan izole edilmesini sağlar.</p></li><li><p>Modül sarıcı, <code>exports</code>, <code>require</code>, <code>module</code>, <code>__filename</code>, <code>__dirname</code> gibi parametreleri içerir. Bu parametreler, modülün işlevselliği için hayati öneme sahiptir.</p></li><li><p><code>__filename</code> ve <code>__dirname</code>, her modül için farklılık gösterir ve modülün dosya ve dizin yollarını temsil eder.</p></li><li><p>Bu yapı, Node.js'te modüler kod yazımını kolaylaştırır ve modüller arası etkileşimi yönetir.</p></li></ul><p>Bu makalede, Node.js'deki modül sarıcısının işlevselliği ve önemi üzerine temel bilgileri inceledik. Bu anlayış, Node.js uygulamalarını daha verimli ve sürdürülebilir bir şekilde geliştirmek için kritik öneme sahiptir.</p>

Node.js'de Modül Sarıcı (Module Wrapper) Anlayışı

<h2><strong>Giriş</strong></h2><p>Node.js, JavaScript tabanlı bir sunucu tarafı programlama platformudur ve modüler yapısı sayesinde geliştiricilere esneklik ve verimlilik sunar. Bu makalede, Node.js'deki modüllerin kapsamını ve bu kapsamın nasıl sağlandığını inceleyeceğiz.</p><h2><strong>Modüllerin Oluşturulması ve Kapsamın Tanımlanması</strong></h2><p>Node.js'de bir modül, bağımsız bir dosya olarak düşünülebilir ve her modül kendi kapsamına sahiptir. Bu, modüller arasındaki değişken ve fonksiyon isimlerinin çakışmasını önler. Örneğin, <code>batman.js</code> ve <code>superman.js</code> isimli iki modül oluşturduğumuzu varsayalım. Her iki modülde de <code>const superhero = "Batman"</code> ve <code>const superhero = "Superman"</code> şeklinde tanımlamalar yapabiliriz. Bu tanımlamalar, her modülün kendi kapsamında yer aldığı için birbiriyle çakışmaz.</p><pre><code>// batman.js
const superhero = "Batman";
console.log(superhero);

// superman.js
const superhero = "Superman";
console.log(superhero);</code></pre><h2><strong>Ana Modül ve İçe Aktarma</strong></h2><p>Bir ana modül (örneğin <code>index.js</code>), diğer modülleri <code>require</code> fonksiyonu kullanarak içe aktarabilir. Bu durumda, her bir modülün içindeki kodlar kendi kapsamında çalıştırılır. Örneğin, <code>index.js</code> içerisinde <code>batman.js</code> ve <code>superman.js</code> modüllerini içe aktardığımızda, her iki modülde tanımlanan <code>superhero</code> değişkeni kendi modüllerinde geçerli olur ve bir çakışma meydana gelmez.</p><pre><code>// index.js
require('./batman');
require('./superman');</code></pre><h2><strong>IIFE (Immediately Invoked Function Expression) ve Node.js</strong></h2><p>Node.js, modül kodlarını kendi kapsamında çalıştırmak için IIFE (Immediately Invoked Function Expression) desenini kullanır. Bu, her modülün bir fonksiyon içerisinde sarılı olduğu ve bu fonksiyonun hemen çağrıldığı anlamına gelir. Bu yöntem, her modülün kendi özel kapsamını oluşturmasını sağlar.</p><pre><code>(function() {
    const superhero = "Batman";
    console.log(superhero);
})();
(function() {
    const superhero = "Superman";
    console.log(superhero);
})();</code></pre><h2><strong>Özet ve Sonuç</strong></h2><ul><li><p>Node.js'de her modül, kendi özel kapsamına sahiptir. Bu, modüller arasında değişken ve fonksiyon adı çakışmalarını önler.</p></li><li><p>Ana modül, <code>require</code> fonksiyonu kullanarak diğer modülleri içe aktarabilir. İçe aktarılan modüller kendi kapsamında çalışır.</p></li><li><p>Node.js, IIFE desenini kullanarak modüllerin kodlarını kendi kapsamlarında çalıştırır. Bu, modüllerin bağımsızlığını ve güvenliğini artırır.</p></li><li><p>Modüler yapı, Node.js'de kodun yeniden kullanılabilirliğini ve sürdürülebilirliğini artırır.</p></li></ul><p>Bu makalede, Node.js'de modüllerin kapsamı ve bu kapsamın nasıl sağlandığı üzerine temel bilgileri inceledik. Node.js'in modüler yapısının anlaşılması, uygulama geliştirme sürecinde verimlilik ve esneklik sağlar.</p>

Module Scope: Node.js Modüllerinde Kapsam Kavramı

<p>Node.js'de modüllerin nasıl kullanıldığını anladığımız önceki yazının devamında, bu sefer modül ihracatı üzerine odaklanacağız. Modül ihracatı, bir modülün belirli işlevlerini dış dünyaya sunarak yeniden kullanılabilir hale getirme işlemidir. Bu işlem, Node.js'in <code>module.exports</code> nesnesi üzerinden gerçekleştirilir.</p><h3><strong>Modül İhracatı Nasıl Yapılır?</strong></h3><p>Bir modülü dışa aktarmak için, öncelikle modül içindeki istenilen fonksiyon veya nesneyi <code>module.exports</code> nesnesine atamak gereklidir. Örneğin, <code>add.js</code> dosyasında tanımladığımız <code>add</code> fonksiyonunu dışa aktaralım:</p><pre><code>// add.js
const add = (a, b) =&gt; a + b;
module.exports = add;</code></pre><p>Bu kod parçasıyla, <code>add</code> fonksiyonunu <code>module.exports</code> nesnesine atayarak dışa aktarmış oluyoruz.</p><h3><strong>Modül İthalatı ve Kullanımı</strong></h3><p>Dışa aktarılan bir modülü başka bir dosyada kullanmak için <code>require</code> fonksiyonunu kullanırız. <code>index.js</code> dosyasında bu modülü şu şekilde ithal edebiliriz:</p><pre><code>// index.js
const add = require('./add');
const sum = add(1, 2);
console.log(sum); // 3</code></pre><p>Bu kod, <code>add.js</code> dosyasından <code>add</code> fonksiyonunu ithal eder ve kullanır.</p><h3><strong>Esnek İsimlendirme</strong></h3><p><code>require</code> ile modülü yüklerken, ithal edilen modül için kullanacağımız sabit adını özgürce belirleyebiliriz. Örneğin, <code>add</code> fonksiyonunu farklı bir isimle ithal edebiliriz:</p><pre><code>// index.js
const addFunction = require('./add');</code></pre><p>Bu esneklik sayesinde, modül içindeki isimlendirmelerden bağımsız olarak dışarıdan erişimde istediğimiz ismi kullanabiliriz.</p><h3><strong>Özet</strong></h3><ul><li><p>Node.js'te, modüller <code>module.exports</code> nesnesi üzerinden dışa aktarılır.</p></li><li><p>Dışa aktarılan modüller, <code>require</code> fonksiyonu ile diğer dosyalara ithal edilebilir.</p></li><li><p>İthal edilen modül için kullanılacak isim, ithal eden tarafından belirlenebilir.</p></li><li><p>Bu yapı, kodun yeniden kullanılabilirliğini ve modülerliğini artırır.</p></li></ul><p>Bu yazımızda, Node.js'te modül ihracatının nasıl yapıldığını ve bu modüllerin başka dosyalarda nasıl kullanılabileceğini öğrendik. İlerleyen yazılarımızda, modüllerle ilgili daha derinlemesine bilgileri ve gelişmiş kullanımları ele alacağız. Bu sayede, Node.js'teki modül sistemini daha iyi anlayacak ve uygulamalarınızda etkin bir şekilde kullanabileceksiniz.</p>

Node.js Module Exports: Modül İhracatı

<p>Node.js, JavaScript tabanlı uygulamalar oluşturmak için güçlü bir platformdur ve bu eğitim serisinde, yerel modüllerin nasıl kullanılacağını öğreneceğiz. Yerel modüller, kendi oluşturduğumuz ve uygulamamızda kullandığımız modüllerdir. Bu modüller, kodunuzu düzenli ve yönetilebilir tutmanıza yardımcı olur.</p><h3><strong>Yerel Modül Oluşturma</strong></h3><p>Yerel bir modül oluşturmak için, öncelikle işlevsellik tanımlamamız gerekir. Örnek olarak, iki sayının toplamını bulan bir fonksiyon oluşturalım. Bu fonksiyon, bir ok fonksiyonu (<code>arrow function</code>) olarak tanımlanabilir ve iki parametre alarak bunların toplamını döndürebilir.</p><pre><code>// add.js
const add = (a, b) =&gt; a + b;</code></pre><p>Bu fonksiyonu, ayrı bir dosyada (<code>add.js</code>) tanımlayarak bir modül haline getirebiliriz. Modüller, Node.js'teki her dosyanın kendi içinde izole edilmiş bir modül olduğu anlayışıyla çalışır. Bu, modüllerin birbirlerinden bağımsız olarak çalıştığı ve yalnızca gerektiğinde diğer dosyalara dahil edildiği anlamına gelir.</p><h3><strong>Modülü Dahil Etme</strong></h3><p>Oluşturduğumuz <code>add.js</code> modülünü başka bir dosyada kullanmak için <code>require</code> fonksiyonunu kullanırız. Örneğin, <code>index.js</code> dosyamızda bu modülü şu şekilde dahil edebiliriz:</p><pre><code>// index.js
const add = require('./add');

console.log(add(1, 2)); // 3</code></pre><p><code>require</code> fonksiyonu, modülün yolunu bir dize olarak alır ve modülü yükler. Yükleme sırasında, modüldeki kod çalıştırılır ve gerektiğinde dışa aktarılır.</p><h3><strong>Modüllerin İzolasyonu ve Debug Modu</strong></h3><p>Node.js modülleri varsayılan olarak izole edilmiştir. Bu, bir modülde hata olsa bile, diğer modüllerin etkilenmeyeceği anlamına gelir. Modüllerin bu izolasyonu, kodun hata ayıklanması ve yönetilmesi açısından önemlidir. Debug modunda çalıştırıldığında, kontrol akışı modülden modüle nasıl geçtiğini gözlemlemek mümkündür.</p><h3><strong>Modül Dosya Uzantıları</strong></h3><p>Node.js'te bir JavaScript dosyasını <code>require</code> ile yüklerken, dosya uzantısını belirtmek zorunda değilsiniz. Eğer uzantı belirtilmezse, Node.js otomatik olarak <code>.js</code> uzantısını ekler. Bu, yaygın bir uygulamadır ve kodun okunabilirliğini artırır.</p><h3><strong>Özet</strong></h3><ul><li><p>Her Node.js dosyası, izole edilmiş bir modüldür.</p></li><li><p>Modüller, <code>require</code> fonksiyonu ile diğer dosyalara dahil edilir.</p></li><li><p>Modül dosyaları izole olduğundan, bir modüldeki hata diğerlerini etkilemez.</p></li><li><p>JavaScript dosyaları için <code>.js</code> uzantısını belirtmek gerekmez; Node.js bu uzantıyı otomatik olarak ekler.</p></li></ul><p>Bu yazıda, Node.js'te yerel modüllerin nasıl oluşturulacağını, nasıl dahil edileceğini ve modüller arasındaki izolasyonun önemini öğrendik. Bir sonraki yazımızda, modüllerden belirli fonksiyonları nasıl dışa aktaracağımızı ve geri kalan kodu nasıl gizli tutacağımızı inceleyeceğiz. Bu sayede, yalnızca gerekli kodu modüller arasında paylaşabileceğiz.</p>

Node.js Yerel (Local) Modüller

<p>Node.js, JavaScript tabanlı bir sunucu tarafı platformudur ve modüler yapısı ile öne çıkar. Bu makalede, Node.js'teki modüllerin ne olduğunu, çeşitlerini ve bu modüllerin nasıl kullanılabileceğini ele alacağız.</p><h3><strong>Modüller Nedir?</strong></h3><p>Node.js'de bir modül, kendi bağlamına sahip, yeniden kullanılabilir ve kapsüllenmiş kod bloklarıdır. Node.js'de her dosya ayrı bir modül olarak ele alınır. Bu, kodun daha düzenli ve yönetilebilir olmasını sağlar.</p><h3><strong>Node.js Modül Türleri</strong></h3><p>Node.js'deki modüller üç ana kategoriye ayrılır:</p><ol><li><p><strong>Yerel (Local) Modüller :</strong> Kendi uygulamamız içinde oluşturduğumuz modüllerdir. Özelleştirilebilir ve uygulamanın belirli ihtiyaçlarına göre şekillendirilebilir.</p></li><li><p><strong>Dahili (Built-in) Modüller:</strong> Node.js'in kendi içerisinde önceden tanımlı modüllerdir. Örneğin, <code>http</code>, <code>fs</code>, <code>path</code> gibi modüller Node.js ile birlikte gelir ve ekstra kuruluma gerek kalmadan doğrudan kullanılabilir.</p></li><li><p><strong>Üçüncü Taraf (Third party) Modüller:</strong> Diğer geliştiriciler tarafından yazılmış ve genellikle npm (Node Package Manager) aracılığıyla erişilebilen modüllerdir. Bu modüller, genişletilebilirlik ve yeniden kullanılabilirlik sağlar.</p></li></ol><h3><strong>Özet</strong></h3><p>Bu makalede Node.js modüllerini öğrendik:</p><ul><li><p><strong>Yerel Modüller:</strong> Kendi oluşturduğumuz, projemize özgü modüller.</p></li><li><p><strong>Dahili Modüller:</strong> Node.js ile gelen hazır modüller.</p></li><li><p><strong>Üçüncü Taraf Modüller:</strong> Diğer geliştiriciler tarafından yazılan ve npm aracılığıyla erişilen modüller.</p></li></ul><p>Her bir modül türü, Node.js uygulamalarınızı daha esnek, yönetilebilir ve ölçeklenebilir hale getirmek için önemli bir rol oynar.</p>

Node.js Modülleri

<p>Node.js, JavaScript geliştiricileri için önemli bir araçtır. Önceki bir yazıda, JavaScript kodunu Node.js kullanarak nasıl çalıştıracağımızı öğrendik. Bu, JavaScript'in tarayıcı dışında da çalıştırılabileceği anlamına gelir. Ancak, tarayıcıda ve Node.js'de yazılan JavaScript kodları arasında bazı temel farklar bulunmaktadır. Bu makalede, bu farklara ve bunların geliştiriciler için önemine detaylı bir şekilde bakacağız.</p><h2><strong>1. DOM ve Web Platformu API'leri</strong></h2><p>Tarayıcıda JavaScript ile sıklıkla yaptığımız işlemler, DOM ile etkileşim kurmak veya çerezler gibi web platformu API'lerini kullanmaktır. Ancak, Node.js'de DOM, <code>document</code>, <code>window</code> gibi tarayıcı tarafından sağlanan nesneler bulunmamaktadır. Bu, Node.js'in sunucu tarafında çalışan uygulamalar için tasarlandığının bir göstergesidir.</p><h2><strong>2. Node.js Modülleri ve API'leri</strong></h2><p>Tarayıcıda bulunmayan pek çok API, Node.js tarafından modüller aracılığıyla sunulur. Örneğin, dosya sistemi erişimi gibi işlevselliği Node.js modülleri sağlar. Bu, Node.js'in dosya işlemleri, ağ işlemleri gibi sunucu tarafı işlemleri için daha uygun olduğunu gösterir.</p><h2><strong>3. Çalışma Ortamı Kontrolü</strong></h2><p>Node.js ile çalışma ortamını kontrol edebiliriz. Hangi Node.js sürümünün kullanıldığını bildiğimiz için, Node.js'in desteklediği modern JavaScript özelliklerini (ES6, ES7 gibi) kullanabiliriz. Buna karşılık, tarayıcıda JavaScript yazarken, kullanıcıların hangi tarayıcıyı ve hangi sürümünü kullandıklarına bağımlı kalırız. Eski bir tarayıcı kullanıyorsa, uyumluluk için ek çalışmalar yapmamız gerekebilir.</p><h2><strong>4. ECMAScript ve V8 Motoru</strong></h2><p>Bu serinin ilk bölümünde, ECMAScript (JavaScript'in standardı) ve Chrome'un V8 motoru hakkında bilgi sahibi olduk. V8 motoru, JavaScript'in tarayıcı dışında, özellikle sunucu tarafında çalıştırılmasını mümkün kılan temel bileşendir.</p><h2><strong>5. Node.js'in Temel Özellikleri</strong></h2><p>Son olarak, JavaScript'in tarayıcı ve Node.js ortamları arasındaki farkları anladık. Bu, geliştiriciler için önemli bir noktadır. Bundan sonraki bölümlerde, Node.js'in özelliklerini, modüllerini ve kullanım alanlarını daha ayrıntılı olarak ele alacağız.</p><h2><strong>Özet</strong></h2><ul><li><p><strong>DOM ve API Erişimi</strong>: Tarayıcı JavaScript'i, DOM ve web platformu API'leri ile etkileşime odaklanırken, Node.js bu özellikleri içermez.</p></li><li><p><strong>Modüller ve API'ler</strong>: Node.js, dosya sistemi erişimi gibi özellikleri modüller aracılığıyla sağlar.</p></li><li><p><strong>Çalışma Ortamı Kontrolü</strong>: Node.js ile hangi sürümün kullanıldığını biliriz ve bu, modern JavaScript özelliklerini rahatlıkla kullanmamızı sağlar.</p></li><li><p><strong>ECMAScript ve V8 Motoru</strong>: JavaScript'in tarayıcı dışında çalıştırılmasını mümkün kılan teknolojilerdir.</p></li><li><p><strong>Node.js Özellikleri</strong>: Node.js, sunucu tarafı uygulamalar için daha uygun özellikler sunar.</p></li></ul><p>Bu bilgiler, Node.js'in tarayıcı bazlı JavaScript'ten nasıl farklı olduğunu ve sunucu tarafı uygulama geliştirmede nasıl bir rol oynadığını anlamak için temel teşkil eder. Önümüzdeki bölümlerde Node.js'in daha derin özelliklerini keşfedeceğiz.</p>

Node.js ve Tarayıcı Arasındaki Farklar

<p>Node.js, JavaScript tabanlı uygulamalar geliştirmek için kullanılan popüler bir platformdur. Bu makalede, Node.js kullanarak basit bir "Hello World" programı yazma sürecini ele alacağız.</p><h2><strong>Node.js Nedir?</strong></h2><p>Node.js, genellikle "node" olarak anılan, JavaScript kodlarını sunucu tarafında çalıştırmayı sağlayan bir platformdur. Bu platform, JavaScript'in sadece tarayıcılarla sınırlı olmadığını göstererek, sunucu tarafı uygulamaları için geniş imkanlar sunar.</p><h2><strong>Geliştirme Ortamını Kurmak</strong></h2><p>Node.js ile çalışmaya başlamak için öncelikle bir metin editörü ve Node.js'in kendisini kurmanız gerekiyor. VS Code gibi popüler bir editörü kullanabilir ve <a target="" rel="noopener noreferrer nofollow" href="https://code.visualstudio.com/">code.visualstudio.com</a> adresinden indirebilirsiniz. Daha sonra <a target="" rel="noopener noreferrer nofollow" href="https://nodejs.org">nodejs.org</a> adresinden Node.js'in en güncel sürümünü indirip kurunuz. Kurulum sırasında varsayılan ayarları korumanız yeterlidir.</p><h2><strong>"Hello World" Programını Yazmak</strong></h2><ol><li><p><strong>Visual Studio Code'u Açın:</strong> Geliştirme için bir klasör oluşturun ve VS Code içinde bu klasörü açın.</p></li><li><p><strong>Terminali Kullanın:</strong> VS Code'da entegre terminali açarak (<code>Ctrl</code> + <code>`</code>) Node.js'in kurulumunu kontrol edebilirsiniz. Terminalde <code>node -v</code> komutunu çalıştırarak yüklü Node.js sürümünü görebilirsiniz.</p></li><li><p><strong>Dosya Oluşturun:</strong> Uygulamanız için bir JavaScript dosyası oluşturun. Genellikle bu dosya <code>app.js</code>, <code>main.js</code> veya <code>index.js</code> olarak adlandırılır. Bu örnekte <code>index.js</code> kullanacağız.</p></li><li><p><strong>Kod Yazın:</strong> <code>index.js</code> dosyasına <code>console.log('Hello from index.js');</code> yazarak basit bir "Hello World" mesajı oluşturun.</p></li><li><p><strong>Programı Çalıştırın:</strong> Terminalde <code>node index.js</code> komutunu çalıştırarak JavaScript kodunuzu Node.js üzerinde çalıştırın.</p></li></ol><h2><strong>Özet</strong></h2><ul><li><p>Node.js kurulumu ve VS Code ile geliştirme ortamı hazırlama.</p></li><li><p>Node.js ile basit bir "Hello World" programı yazma.</p></li><li><p>JavaScript kodunu Node.js üzerinde nasıl çalıştıracağınızı öğrenme.</p></li></ul><p>Bu makalede Node.js kullanarak temel bir "Hello World" uygulaması nasıl yazılacağını öğrendik. Bu basit başlangıç, Node.js ile sunucu tarafı uygulamaları geliştirmeye yönelik yolculuğunuzda ilk adımınız olabilir.</p>

Node.js Kurulumu

<h2><strong>Node.js'in Tanımı ve Temel Özellikleri</strong></h2><p>Node.js, JavaScript kodlarının tarayıcı dışında çalıştırılmasına olanak tanıyan açık kaynaklı, çapraz platform bir JavaScript çalışma ortamıdır. Bu, 2009 yılında Node.js'in ortaya çıkışıyla mümkün hale geldi. JavaScript, daha önce sadece tarayıcı içinde çalıştırılabiliyorken, Node.js sayesinde tarayıcı dışında da çalıştırılabilmekte ve böylece yeni kullanım alanlarına açılmaktadır.</p><h3><strong>Anahtar Özellikler:</strong></h3><ol><li><p><strong>Açık Kaynak</strong>: Node.js'in kaynak kodları herkes tarafından erişilebilir ve değiştirilebilir.</p></li><li><p><strong>Çapraz Platform</strong>: Mac, Windows ve Linux işletim sistemlerinde çalışabilir.</p></li><li><p><strong>JavaScript Çalışma Ortamı</strong>: JavaScript programlarını çalıştırabilmek için gerekli tüm bileşenleri sağlar.</p></li></ol><h3><strong>Tarayıcı Dışı JavaScript</strong></h3><p>Node.js'in en önemli özelliği, JavaScript programlarını tarayıcı dışında çalıştırabilmesidir. Bu, JavaScript'in kullanım alanlarını genişletmiş ve geleneksel web siteleri, arka uç hizmetleri, gerçek zamanlı uygulamalar, streaming servisleri, komut satırı araçları ve çok oyunculu oyunlar gibi çeşitli alanlarda kullanılmasına imkan tanımıştır.</p><h2><strong>Node.js'in Yapısı ve Bileşenleri</strong></h2><p>Node.js, C++ ve JavaScript dillerinde yazılmıştır. Yapısını anlamak için GitHub'daki <a target="_new" rel="noopener noreferrer nofollow" href="https://github.com/nodejs/node">node.js/node</a> deposundaki üç ana klasörü inceleyebiliriz:</p><ol><li><p><strong>Dependecies (Bağımlılıklar) Klasörü</strong>: Node.js'in işlevselliği için gerekli dış kodları içerir. Önemli bağımlılıklardan biri V8 JavaScript motorudur, bu Chrome tarayıcısında da kullanılır. Diğeri ise libuv adında bir açık kaynak kütüphanesidir ki bu, dosya sistemi ve ağ gibi işletim sistemi özelliklerine erişim sağlar.</p></li><li><p><strong>Source (Kaynak) Klasörü</strong>: Node.js'in C++ kaynak kodlarını içerir. JavaScript dilinin düşük seviye işlevlerle başa çıkma kapasitesi olmadığından, bu işlevler C++ ile yazılmıştır.</p></li><li><p><strong>Lib (Kütüphane) Klasörü</strong>: JavaScript geliştiricilerinin C++ özelliklerine erişimini kolaylaştıran JavaScript kodlarını içerir. Örneğin, <code>fs.js</code> dosya sistemi ile etkileşimde bulunmak için kullanılan JavaScript kodunu içerir.</p></li></ol><h3><strong>Önemli Noktalar:</strong></h3><ul><li><p>Node.js, tarayıcı tabanlı JavaScript çalışma ortamından farklı olarak, web API'lerine erişemez. Yani, <code>window</code> veya <code>document</code> gibi nesneler Node.js'de kullanılamaz.</p></li><li><p>Node.js, bir dil veya çerçeve değil, JavaScript kodlarını çalıştıran bir çalışma ortamıdır.</p></li></ul><h2><strong>Node.js İle Yapılabilecekler</strong></h2><p>Node.js, JavaScript'in sınırlarını zorlayarak, kullanıcılarına geniş bir yelpazede uygulama geliştirme imkanı sunar. İster geleneksel bir web sitesi, ister bir API servisi, isterse de gerçek zamanlı bir uygulama olsun, Node.js ile geliştirilebilir. Netflix gibi streaming servisleri ve çok oyunculu oyunlar da Node.js kullanılarak oluşturulabilir.</p><h2><strong>Özet</strong></h2><ul><li><p>Node.js, JavaScript kodlarını tarayıcı dışında çalıştırmayı sağlayan açık kaynaklı ve çapraz platform bir çalışma ortamıdır.</p></li><li><p>Çeşitli türde uygulamalar geliştirebilmek için JavaScript'e yeni özellikler ekler.</p></li><li><p>Temel bileşenleri, JavaScript ile etkileşime geçen C++ kodları ve bu kodlara JavaScript üzerinden erişimi sağlayan kütüphanelerdir.</p></li><li><p>Web API'lerine erişimi olmayan, tarayıcı dışı bir ortamdır.</p></li></ul><p>Bu makalede Node.js'in ne olduğunu, temel özelliklerini ve yapısını öğrendik. Bir sonraki adımda, Node.js ile basit bir "Hello World" programı yazarak pratiğe dökmemiz mümkün olacak.</p>

Node.js Nedir?

<h3><strong>JavaScript Çalışma Ortamı Nedir?</strong></h3><p>Bu makalede, JavaScript'in çalışma ortamını ve Node.js ile olan ilişkisini inceleyeceğiz.</p><p>JavaScript çalışma ortamı, JavaScript programlarının kullanılmasını ve çalıştırılmasını sağlayan bileşenleri içeren bir ortamdır. Önceki yazıda bahsedildiği üzere, her tarayıcının bir JavaScript motoru bulunur. Aslında, JavaScript motoru, JavaScript çalışma ortamının bir bileşenidir.</p><p>Peki, JavaScript çalışma ortamı başka nelerden oluşur? Chrome tarayıcısını örnek alarak bu soruya cevap verelim. Chrome'da yazdığımız JavaScript kodu, şu bileşenleri içeren Chrome'un JavaScript çalışma ortamında yürütülür: JavaScript motoru, web API'leri, kuyruklar ve bir olay döngüsü.</p><h3><strong>JavaScript Motoru ve Diğer Bileşenler</strong></h3><ol><li><p><strong>JavaScript Motoru:</strong> Chrome'da bu, V8 motorudur ve JavaScript kodunu yürütür. Bir çağrı yığını ve uygulamanın ihtiyaç duyduğu tüm değişkenleri saklamak için bir bellek alanı (heap) içerir.</p></li><li><p><strong>Web API'leri:</strong> DOM, <code>setTimeout</code>, <code>setInterval</code>, promisler, tarayıcı depolama gibi JavaScript motoruna ek işlevsellikler ekleyen ancak JavaScript dilinin kendisi olmayan araçlardır.</p></li><li><p><strong>Kuyruklar:</strong> Asenkron görevlerin yürütülmeden önce beklediği yerlerdir.</p></li><li><p><strong>Olay Döngüsü:</strong> Asenkron görevlerin doğru sırayla yürütülmesini sağlar.</p></li></ol><p>Bu bileşenler, tarayıcıda JavaScript çalışma ortamının genel bir özetidir. JavaScript motoru yalnızca ECMAScript'i yürütebilirken, günlük kullandığımız JavaScript kodu, ECMAScript'in yanı sıra <code>console.log</code>, <code>setTimeout</code>, DOM API'leri gibi web API'leri de içerir. Bu nedenle, bir tarayıcının, JavaScript kodunu çalıştırmak için sadece bir JavaScript motoruna değil, aynı zamanda bir JavaScript çalışma ortamına ihtiyacı vardır.</p><h3><strong>Node.js ve Tarayıcı Çalışma Ortamları Arasındaki Fark</strong></h3><p>Node.js'in tanımına geri döndüğümüzde, Node.js çalışma ortamının tarayıcılarınkine nasıl farklı olduğunu görebiliriz. ECMAScript'in ne olduğunu anlamak, JavaScript motorunun ve dolayısıyla JavaScript çalışma ortamının ne olduğunu anlamamıza yardımcı olur.</p><h3><strong>Sonuç</strong></h3><p>Bu makalede öğrendiklerimizi özetleyecek olursak:</p><ol><li><p>JavaScript çalışma ortamı, JavaScript kodlarının çalıştırılmasını sağlayan bir dizi bileşenden oluşur.</p></li><li><p>Bu bileşenler arasında JavaScript motoru, web API'leri, kuyruklar ve olay döngüsü bulunur.</p></li><li><p>JavaScript motoru yalnızca ECMAScript'i yürütürken, web API'leri gibi ek bileşenlerle zenginleştirilmiş JavaScript kullanıyoruz.</p></li><li><p>Node.js ve tarayıcı çalışma ortamları, JavaScript'i çalıştırma biçimleri açısından farklılık gösterir.</p></li></ol><p>Bu bilgiler, Node.js ve JavaScript dünyasına daha derinlemesine bir bakış sağlar. Geliştiriciler için, bu temel bilgilerin anlaşılması, daha karmaşık Node.js uygulamaları geliştirirken büyük önem taşır.</p>

JavaScript Runtime: JavaScript Çalışma Ortamı

<p>Node.js, JavaScript'in sunucu tarafında kullanılmasını mümkün kılan popüler bir platformdur. Bu platformun temelinde, Google Chrome tarayıcısının JavaScript motoru olan V8 yer alır. Bu makalede, V8 motorunun Node.js için neden bu kadar önemli olduğunu ve bu teknolojinin nasıl çalıştığını anlayacağız.</p><h3><strong>JavaScript Motoru Nedir?</strong></h3><p>JavaScript kodu, bilgisayarlar tarafından doğrudan anlaşılamaz. Bu kodun, makine koduna çevrilmesi gerekir. İşte burada devreye JavaScript motorları girer. Bu motorlar, geliştiriciler tarafından yazılan JavaScript kodunu alır ve bilgisayarların anlayabileceği makine koduna dönüştürür. Temelde, bir JavaScript motoru, JavaScript kodunu yorumlayıp çalıştırabilir.</p><h3><strong>Tarayıcı Bazlı JavaScript Motorları</strong></h3><p>Farklı web tarayıcıları, kendi JavaScript motorlarını geliştirmişlerdir. Her büyük tarayıcı için farklı JavaScript motorları bulunur:</p><ul><li><p><strong>V8:</strong> Google tarafından Chrome için geliştirilen açık kaynaklı JavaScript motoru.</p></li><li><p><strong>SpiderMonkey:</strong> Mozilla tarafından Firefox için geliştirilen JavaScript motoru.</p></li><li><p><strong>JavaScriptCore:</strong> Apple tarafından Safari için geliştirilen JavaScript motoru.</p></li><li><p><strong>Chakra:</strong> Microsoft tarafından orijinal Edge tarayıcısı için geliştirilen JavaScript motoru.</p></li></ul><p>Bu motorlar arasında, Node.js'in temelinde yatan V8 motoru özellikle önemlidir.</p><h3><strong>V8 Motorunun Özellikleri</strong></h3><ul><li><p><strong>Açık Kaynaklı:</strong> V8, Google tarafından geliştirilen açık kaynaklı bir JavaScript motorudur.</p></li><li><p><strong>ECMAScript Uyumluluğu:</strong> V8, ECMAScript standartlarına (ECMA-262) uygun olarak çalışır. ECMAScript, JavaScript'in standardize edilmiş bir versiyonudur.</p></li><li><p><strong>C++ ile Yazılmış:</strong> V8 motoru, C++ programlama dili kullanılarak yazılmıştır.</p></li><li><p><strong>Bağımsız veya Gömülü Kullanım:</strong> V8, bağımsız bir şekilde kullanılabileceği gibi, C++ uygulamalarına da gömülebilir. Bu özellik, Node.js'in geliştirilmesinde kritik bir rol oynamıştır.</p></li></ul><h3><strong>Node.js ve V8</strong></h3><p>Node.js, V8 motorunu kullanarak JavaScript'in sadece tarayıcı dışında, sunucu tarafında da çalışmasını sağlar. V8'in C++ ile yazılması ve gömülü kullanım özelliği sayesinde, Node.js; dosya işlemleri, veritabanı bağlantıları ve ağ işlemleri gibi düşük seviye operasyonları JavaScript aracılığıyla gerçekleştirebilir.</p><h2><strong>Özet</strong></h2><ul><li><p><strong>JavaScript Motoru:</strong> JavaScript kodunu makine koduna dönüştüren program.</p></li><li><p><strong>V8'in Önemi:</strong> Google tarafından geliştirilen, C++ ile yazılmış ve ECMAScript standartlarına uygun çalışan açık kaynaklı JavaScript motoru.</p></li><li><p><strong>Node.js ile İlişkisi:</strong> Node.js, V8 motorunu kullanarak JavaScript'i sunucu tarafında çalıştırır ve JavaScript'e yeni özellikler ekleyebilir.</p></li></ul><p>Bu makale, V8 motorunun temel özelliklerini ve Node.js ile olan ilişkisini açıklamaktadır. Node.js'in daha derinlemesine anlaşılabilmesi için V8 motorunun anlaşılması büyük önem taşır. Bu bilgi, Node.js'in nasıl çalıştığını ve JavaScript'in sunucu tarafında nasıl kullanılabileceğini anlamamızda bize yardımcı olur.</p>

JavaScript Motorları ve Chrome'un V8 Motorunun Önemi

<p>Node.js'in temellerini anlamanın ilk adımı ECMAScript'i keşfetmekle başlar. Bu makalede, ECMAScript'in tarihçesinden başlayarak, JavaScript ile olan ilişkisine ve Node.js ile nasıl entegre olduğuna kadar geniş bir yelpazede bilgi sunacağız.</p><h2><strong>ECMAScript'in Tarihçesi</strong></h2><p>ECMAScript hikayesi, 1993 yılında kullanıcı arayüzüne sahip ilk web tarayıcısı olan Mosaic'in piyasaya sürülmesiyle başlar. Bu dönemde, web sayfaları statikti ve yüklenen bir sayfada herhangi bir dinamik etkileşim bulunmuyordu. 1995 yılında Netscape, bu durumu değiştirecek JavaScript adlı yeni bir betik dili oluşturdu. JavaScript, o dönem popüler olan Java dilinin isminden ilham alarak piyasaya sürülmüştü.</p><p>Bu gelişme, Microsoft'un Internet Explorer tarayıcısını da etkiledi. Microsoft, JavaScript'in web kullanıcı deneyimini temelden değiştirdiğini fark ederek kendi betik dilini, JScript'i geliştirdi. Ancak, JScript ve JavaScript arasındaki farklılıklar, geliştiricilerin her iki tarayıcıda da sorunsuz çalışan web siteleri oluşturmasını zorlaştırdı. Sonuç olarak, Netscape 1996 yılında JavaScript'i ECMA International'a standartlaştırması için sundu.</p><h2><strong>ECMAScript Nedir?</strong></h2><p>ECMA International, bilgi ve iletişim sistemlerinin standartlaştırılmasına adanmış bir endüstri derneğidir. JavaScript'in ECMA tarafından standartlaştırılması sonucu, ECMAScript adında bir dil ortaya çıktı. ECMAScript, JavaScript'in resmi dil standartıdır ve teknik olarak "ECMA-262" olarak adlandırılır. Oracle'ın "JavaScript" terimi üzerindeki ticari hakları nedeniyle bu isimlendirme yapılmıştır.</p><p>ECMAScript'in çeşitli versiyonları bulunmaktadır. Özellikle, ES2015 (ya da ES6 olarak da bilinir) modern JavaScript özelliklerini sunarak, JavaScript geliştiricileri için bir dönüm noktası olmuştur. Bu versiyon, Node.js ile çalışırken de temel bir ön koşul olarak kabul edilir.</p><h2><strong>JavaScript ve ECMAScript Arasındaki İlişki</strong></h2><p>Teknik olarak, ECMAScript ve JavaScript aynı şey değildir. Ancak, pratikte bu iki terim genellikle birbirinin yerine kullanılır. JavaScript, ECMAScript'in temelini oluşturur, ancak üzerine ek özellikler ve API'ler ekleyerek daha geniş bir kullanım alanı sunar. Bu makalede ve genel olarak Node.js dünyasında, ECMAScript ve JavaScript terimlerini aynı anlamda kullanacağız.</p><h2><strong>Node.js ile ECMAScript'in Entegrasyonu</strong></h2><p>Node.js, JavaScript'in sunucu tarafında kullanılmasını sağlayan bir platformdur. ECMAScript'in standartları, Node.js'in temelini oluşturur ve Node.js, ECMAScript spesifikasyonlarına dayalı olarak JavaScript'i yorumlar. Bu, Node.js geliştiricilerinin modern JavaScript özelliklerinden yararlanmasını ve tarayıcılar arası uyumlu kodlar yazmasını sağlar.</p><h2><strong>Özet</strong></h2><p>Bu makalede, ECMAScript'in tarihçesini, JavaScript ile olan ilişkisini ve Node.js ile entegrasyonunu inceledik:</p><ol><li><p>ECMAScript, JavaScript'in resmi dil standardıdır ve teknik olarak ECMA-262 olarak adlandırılır.</p></li><li><p>ECMAScript ve JavaScript, teknik olarak farklı olsalar da, pratikte birbirlerinin yerine kullanılır.</p></li><li><p>Node.js, ECMAScript standardına dayanarak JavaScript kodlarını yorumlar ve sunucu tarafında çalışmasını sağlar.</p></li><li><p>ECMAScript'in farklı versiyonları, özellikle ES6, modern JavaScript geliştirmenin temelini oluşturur.</p></li></ol><p>Bu bilgiler ışığında, ECMAScript ve JavaScript'in Node.js dünyasındaki önemini daha iyi anlamış olabiliriz. </p>

Node.js ve ECMAScript'in Evrimi: JavaScript'in Temellerini Anlamak

<p>Python, veri depolamak ve manipüle etmek için çeşitli veri yapıları sunar. Bu veri yapılarından biri de demetlerdir (tuples). Demetler, listelere benzerler, ancak bir kez oluşturulduklarında içerdikleri değerleri değiştiremezsiniz. Bu makalede, demetleri ve onları nasıl kullanabileceğinizi öğreneceksiniz.</p><h2><strong>Demet Oluşturma</strong></h2><p>Demet oluşturmak için parantez <code>()</code> kullanılır ve içerisine virgülle ayrılmış değerler eklenir.</p><pre><code>meyveler = ("elma", "muz", "kiraz")
print(meyveler)  # Çıktı: ('elma', 'muz', 'kiraz')</code></pre><p><span>Tek bir elemana sahip bir demet oluştururken, elemanın sonuna bir virgül koymak önemlidir.</span></p><pre><code>tekli = ("elma",)
print(type(tekli))  # Çıktı: &lt;class 'tuple'&gt;</code></pre><h2><strong>Demet Elemanlarına Erişim</strong></h2><p>Demetler üzerinde indeksleme ve dilimleme işlemleri yapabilirsiniz.</p><pre><code>meyveler = ("elma", "muz", "kiraz")
print(meyveler[0])  # Çıktı: elma
print(meyveler[1:3])  # Çıktı: ('muz', 'kiraz')</code></pre><h2><strong>Demet İçinde Demet</strong></h2><p>Demetler, diğer demetleri de içerebilir.</p><pre><code>nested = (("elma", "muz"), ("kiraz", "üzüm"))
print(nested[0])  # Çıktı: ('elma', 'muz')</code></pre><h2><strong>Demetlerin Değiştirilemez Olması</strong></h2><p>Demetler değiştirilemezdir, yani içerdikleri değerleri değiştiremezsiniz.</p><pre><code>meyveler = ("elma", "muz", "kiraz")
meyveler[0] = "armut"  # Hata: 'tuple' object does not support item assignment</code></pre><p><span>Ancak, demet içinde listeler bulunuyorsa, listenin elemanları değiştirilebilir.</span></p><pre><code>demet = ([1, 2, 3], [4, 5, 6])
demet[0][0] = 99
print(demet)  # Çıktı: ([99, 2, 3], [4, 5, 6])</code></pre><h2><strong>Demet Metodları</strong></h2><p>Demetler, listelere göre daha az metoda sahiptir. Ancak, <code>count()</code> ve <code>index()</code> gibi bazı kullanışlı metodlara sahiptirler.</p><pre><code>meyveler = ("elma", "muz", "kiraz", "elma")
print(meyveler.count("elma"))  # Çıktı: 2
print(meyveler.index("kiraz"))  # Çıktı: 2</code></pre><h2><strong>Sonuç</strong></h2><p>Demetler, Python'da sabit bir dizi oluşturmanın yollarından biridir. Değiştirilemez olmaları, programınızın bazı kısımlarında sabit bir değer kümesi oluşturmanız gerektiğinde yararlıdır. Bu özellik, demetleri, programınızın değişmemesi gereken verileri saklamak için güvenli bir seçenek haline getirir.</p>

Python'da Demetler (Tuples): Sabit Listeler

<p><code>range()</code><span> fonksiyonu, Python'da sayı dizileri oluşturmak için sıkça kullanılan bir fonksiyondur. Bu fonksiyon, özellikle for döngüleri ile birlikte kullanıldığında oldukça etkilidir. Bu makalede, </span><code>range()</code><span> fonksiyonunun nasıl kullanılacağını ve farklı parametreler ile nasıl farklı sayı dizileri oluşturabileceğinizi öğreneceksiniz.</span></p><h2><strong>Temel Kullanım</strong></h2><p><code>range()</code> fonksiyonu, bir başlangıç değeri, bir bitiş değeri ve bir adım büyüklüğü alabilir. En basit haliyle, sadece bir parametre ile kullanıldığında, 0'dan başlayarak (dahil) verilen sayıya kadar (hariç) bir dizi oluşturur.</p><pre><code>for i in range(5):
    print(i)</code></pre><p><span>Çıktı:</span></p><pre><code>0
1
2
3
4</code></pre><h2><strong>Başlangıç ve Bitiş Değerleri</strong></h2><p><code>range()</code> fonksiyonuna iki parametre verdiğinizde, ilk parametre başlangıç değerini, ikinci parametre bitiş değerini belirtir.</p><pre><code>for i in range(2, 7):
    print(i)</code></pre><p><span>Çıktı:</span></p><pre><code>2
3
4
5
6</code></pre><h2><strong>Adım Büyüklüğü</strong></h2><p><code>range()</code> fonksiyonuna üçüncü bir parametre ekleyerek adım büyüklüğünü belirleyebilirsiniz. Bu, sayı dizisinin hangi aralıklarla oluşturulacağını kontrol etmenizi sağlar.</p><pre><code>for i in range(0, 10, 2):
    print(i)</code></pre><p><span>Çıktı:</span></p><pre><code>0
2
4
6
8</code></pre><h2><strong>Ters Sayı Dizileri</strong></h2><p><code>range()</code> fonksiyonunu kullanarak ters sayı dizileri de oluşturabilirsiniz. Bu durumda, başlangıç değeri bitiş değerinden büyük olmalı ve adım büyüklüğü negatif olmalıdır.</p><pre><code>for i in range(5, 0, -1):
    print(i)</code></pre><p><span>Çıktı:</span></p><pre><code>5
4
3
2
1</code></pre><h2><strong>range() ve Listeler</strong></h2><p><code>range()</code> fonksiyonu ile oluşturulan sayı dizisi doğrudan bir listeye dönüştürülebilir.</p><pre><code>sayilar = list(range(5))
print(sayilar)  # Çıktı: [0, 1, 2, 3, 4]</code></pre><h2><strong>Sonuç</strong></h2><p><code>range()</code> fonksiyonu, Python'da for döngüleri ile birlikte kullanılarak tekrarlayan işlemleri kolayca gerçekleştirebileceğiniz güçlü bir araçtır. Başlangıç, bitiş ve adım büyüklüğü parametrelerini kullanarak çeşitli sayı dizileri oluşturabilir ve bu sayıları döngülerde kullanabilirsiniz. Bu, yazılım geliştirme sürecinizi hızlandırır ve kodunuzu daha etkili hale getirir.</p>

Python'da Range() Fonksiyonu: Sayı Dizileri Oluşturmak

<p>Python programlama dilinde, tekrarlayan işlemleri yapmak için döngüler kullanılır. Bu makalede, özellikle yazılıma yeni başlayanlar için <code>for</code> döngülerinin nasıl kullanılacağı anlatılmaktadır.</p><h2><strong>For Döngüsü Temelleri</strong></h2><p><code>for</code> döngüsü, bir dizi üzerinde iterasyon yapmak için kullanılır. Bu dizi bir liste, demet, string veya başka bir iterable (tekrarlanabilir) nesne olabilir.</p><pre><code>for i in [1, 2, 3, 4, 5]:
    print(i)</code></pre><p>Bu örnek, bir listenin üzerinde döngü yaparak her bir elemanı ekrana bastırır.</p><h2><strong>range() Fonksiyonu ile For Döngüsü</strong></h2><p><code>range()</code> fonksiyonu, belirli bir aralıkta sayılar üretir ve bu sayıları <code>for</code> döngüsünde kullanabiliriz.</p><pre><code>for i in range(5):
    print(i)</code></pre><p><span>Çıktı:</span></p><pre><code>0
1
2
3
4</code></pre><p><span>Eğer </span><code>range()</code><span> fonksiyonuna iki parametre verirseniz, ilk parametre başlangıç değerini, ikinci parametre bitiş değerini belirtir.</span></p><pre><code>for i in range(1, 6):
    print(i)</code></pre><p><span>Çıktı:</span></p><pre><code>1
2
3
4
5</code></pre><h2><strong>For Döngüsü ve Listeler</strong></h2><p><code>for</code> döngüsü, listelerle birlikte kullanıldığında oldukça güçlüdür.</p><pre><code>meyveler = ["elma", "muz", "kiraz"]
for meyve in meyveler:
    print(meyve)</code></pre><p><span>Çıktı:</span></p><pre><code>elma
muz
kiraz</code></pre><h2><strong>For Döngüsü ve Stringler</strong></h2><p><code>for</code> döngüsü, stringler üzerinde de iterasyon yapabilir.</p><pre><code>kelime = "python"
for harf in kelime:
    print(harf)</code></pre><p><span>Çıktı:</span></p><pre><code>p
y
t
h
o
n</code></pre><h2><strong>For Döngüsü ile İndeks Kullanımı</strong></h2><p>Bazen, elemanın yanı sıra indekse de ihtiyacınız olabilir. Bu durumda <code>enumerate()</code> fonksiyonunu kullanabilirsiniz.</p><pre><code>meyveler = ["elma", "muz", "kiraz"]
for indeks, meyve in enumerate(meyveler):
    print(indeks, meyve)</code></pre><p><span>Çıktı:</span></p><pre><code>0 elma
1 muz
2 kiraz</code></pre><h2><strong>Sonuç</strong></h2><p><code>for</code> döngüsü, Python'da tekrarlayan işlemleri yapmanın temel yollarından biridir. Listeler, stringler ve <code>range()</code> fonksiyonu ile birlikte kullanılarak çeşitli iterasyon işlemleri gerçekleştirilebilir. Bu döngü tipi, kodunuzu daha okunabilir ve etkili hale getirirken aynı zamanda yazılım geliştirme sürecinizi hızlandırır.</p>

Python'da For Döngüleri: Tekrarlayan İşlemleri Kolayca Yapma

<p>Listeler, Python programlama dilinde oldukça yaygın olarak kullanılan veri yapılarıdır. Python listeleri üzerinde çeşitli işlemleri gerçekleştirebilmek için birçok faydalı metot bulunmaktadır. Bu makalede, Python'da listeler üzerinde kullanabileceğiniz bazı temel metotları inceleyeceğiz.</p><h2><strong>append()</strong></h2><p><code>append()</code> metodu, listeye yeni bir eleman eklemek için kullanılır.</p><pre><code>meyveler = ["elma", "muz", "kiraz"]
meyveler.append("portakal")
print(meyveler)  # Çıktı: ['elma', 'muz', 'kiraz', 'portakal']</code></pre><h2><strong>insert()</strong></h2><p><code>insert()</code> metodu, belirtilen bir indekse eleman eklemek için kullanılır.</p><pre><code>meyveler.insert(1, "çilek")
print(meyveler)  # Çıktı: ['elma', 'çilek', 'muz', 'kiraz', 'portakal']</code></pre><h2><strong>extend()</strong></h2><p><code>extend()</code> metodu, bir listenin elemanlarını başka bir listeyle genişletmek için kullanılır.</p><pre><code>sebzeler = ["domates", "biber", "patlıcan"]
meyveler.extend(sebzeler)
print(meyveler)  # Çıktı: ['elma', 'çilek', 'muz', 'kiraz', 'portakal', 'domates', 'biber', 'patlıcan']</code></pre><h2><strong>remove()</strong></h2><p><code>remove()</code> metodu, belirtilen bir değeri listeden kaldırmak için kullanılır. Eğer değer listede birden fazla kez bulunuyorsa, ilk bulunan değer kaldırılır.</p><pre><code>meyveler.remove("çilek")
print(meyveler)  # Çıktı: ['elma', 'muz', 'kiraz', 'portakal', 'domates', 'biber', 'patlıcan']</code></pre><h2><strong>pop()</strong></h2><p><code>pop()</code> metodu, belirtilen indeksteki elemanı kaldırır ve kaldırılan elemanı döndürür. İndeks belirtilmezse, listenin son elemanı kaldırılır ve döndürülür.</p><pre><code>eleman = meyveler.pop(2)
print(eleman)  # Çıktı: kiraz
print(meyveler)  # Çıktı: ['elma', 'muz', 'portakal', 'domates', 'biber', 'patlıcan']</code></pre><h2><strong>index()</strong></h2><p><code>index()</code> metodu, belirtilen değerin listedeki indeksini döndürür.</p><pre><code>indeks = meyveler.index("muz")
print(indeks)  # Çıktı: 1</code></pre><h2><strong>count()</strong></h2><p><code>count()</code> metodu, belirtilen değerin listede kaç kez geçtiğini döndürür.</p><pre><code>meyveler.append("elma")
sayi = meyveler.count("elma")
print(sayi)  # Çıktı: 2</code></pre><h2><strong>reverse()</strong></h2><p><code>reverse()</code> metodu, listenin sırasını tersine çevirir.</p><pre><code>meyveler.reverse()
print(meyveler)  # Çıktı: ['patlıcan', 'biber', 'domates', 'portakal', 'muz', 'elma', 'elma']</code></pre><h2><strong>sort()</strong></h2><p><code>sort()</code> metodu, listeyi sıralar.</p><pre><code>sayilar = [3, 1, 4, 1, 5, 9, 2]
sayilar.sort()
print(sayilar)  # Çıktı: [1, 1, 2, 3, 4, 5, 9]</code></pre><h2><strong>Sonuç</strong></h2><p>Python'daki listeler, çok yönlü ve kullanışlı veri yapılarıdır. <code>append()</code>, <code>insert()</code>, <code>extend()</code>, <code>remove()</code>, <code>pop()</code>, <code>index()</code>, <code>count()</code>, <code>reverse()</code> ve <code>sort()</code> gibi metotlar sayesinde listeler üzerinde çeşitli işlemleri kolayca gerçekleştirebilirsiniz. Bu metotları kullanarak programlarınızı daha etkili ve verimli hale getirebilir, verilerinizi daha düzenli bir şekilde yönetebilirsiniz.</p>

Güncel Makaleler

JavaScript'e Hızlı Başlangıç

DOM: JavaScript Programlamada Belge Nesne Modeli

JavaScript'e Hızlı Başlangıç

Fonksiyon Türleri: JavaScript Programlamada Fonksiyon Tipleri

JavaScript'e Hızlı Başlangıç

Functions: JavaScript Programlamada Fonksiyonlar

JavaScript'e Hızlı Başlangıç

Arrays: JavaScript Programlamada Diziler

JavaScript'e Hızlı Başlangıç

Objects: JavaScript Programlamada Nesneler

JavaScript'e Hızlı Başlangıç

Referans Veri Tipleri: JavaScript Programlamada Referans Tipler

JavaScript'e Hızlı Başlangıç

Dinamik Tip Belirleme: JavaScript Programlamada Dinamik Tipler

JavaScript'e Hızlı Başlangıç

Primitive Tipler: JavaScript Programlamada Primitive Tipler

JavaScript'e Hızlı Başlangıç

Constants: JavaScript Programlamada Sabitler

JavaScript'e Hızlı Başlangıç

Değişkenler: JavaScript Programlamada Temel Taşlar

JavaScript'e Hızlı Başlangıç

VSCode ile JavaScript Kurulumu: Adım Adım Rehber

JavaScript'e Hızlı Başlangıç

JavaScript ile Neler Yapabilirsiniz?

JavaScript'e Hızlı Başlangıç

JavaScript’e Giriş: JavaScript Nedir ve Diğer Programlama Dillerinden Farkları

Sıfırdan Node.js Serisi

Node.js Worker Threads Modülü: Performans ve Paralel İşleme için Güçlü Bir