Sıfırdan Node.js Serisi

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

<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ı

<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?

<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

<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ı 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 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'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ı

<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ı

<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 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 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'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

<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

<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><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>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>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>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 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, 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><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, 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>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>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, 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><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

<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ü

<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>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ı

<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

<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

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

<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, 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, 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, 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, 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, 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, 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 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, 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, 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 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>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 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 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 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 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>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, 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>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 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>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 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>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, 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, 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>