node.js'deki olay döngüsü

Node Js Deki Olay Dongusu



Node.js, kullanıcıların Javascript kodunu tarayıcı dışında sunucuda çalıştırmasına olanak tanıyan güçlü bir Javascript çerçevesidir. Güvenilir ölçeklenebilir web uygulamaları oluşturmak için engellemeyen, olaya dayalı bir çalışma zamanı ortamıdır. Olay döngüsü, Node.js'nin önemli bir parçasıdır ve görevleri, birinin bitmesini beklemeden diğerine başlamadan önce yapmanıza olanak tanır.

Javascript tek iş parçacıklı bir dil olmasına rağmen Node.js, işletim sistemine görevler atayarak sistemin aynı anda birden fazla görevi işlemesine olanak tanır. İşletim sistemindeki işlemler çok iş parçacıklı olduğundan birden fazla görevin aynı anda tamamlanması gerekir. Her işlemle ilişkili geri çağırma, olay kuyruğuna eklenir ve Node.js tarafından belirtilen görev tamamlandığında çalışacak şekilde zamanlanır.

Verimli ve güvenilir Node.js kodu yazmak için kullanıcının olay döngüleri hakkında sağlam bir anlayışa sahip olması gerekir. Ayrıca performans sorunlarının etkili bir şekilde giderilmesine de yardımcı olabilir. Node.js'deki olay döngüsü bellekten tasarruf sağlar ve her birinin bitmesini beklemek zorunda kalmadan aynı anda birden fazla şey yapmanıza olanak tanır. 'Eşzamansız' terimi, arka planda gelen istekleri engellemeden çalışan herhangi bir Javascript işlevini ifade eder.







Doğrudan olay döngülerine geçmeden önce Javascript programlama dilinin farklı yönlerine bir göz atalım.



Eşzamansız bir programlama dili olarak Javascript

Asenkron programlama kavramlarına bir göz atalım. Javascript web, mobil ve masaüstü uygulamalarında kullanılmaktadır ancak Javascript'in tek iş parçacıklı, senkronize bir bilgisayar programlama dili olduğunu unutmamak gerekir.



Kavramın anlaşılması için basit bir kod örneği verilmiştir.





fonksiyon yöntemi1 ( ) {

konsol. kayıt ( 'İşlev 1' )

}

fonksiyon yöntemi2 ( ) {

konsol. kayıt ( 'İşlev 2' )

}

Yöntem 1 ( )

yöntem2 ( )

Bu kodda, iki basit fonksiyon oluşturulur ve önce yöntem1 çağrılır, böylece önce yöntem1'i günlüğe kaydeder ve sonra bir sonrakine geçer.

Çıktı



Senkron programlama dili olarak Javascript

Javascript senkron bir programlama dilidir ve her satırı yukarıdan aşağıya doğru adım adım yürütür ve aynı anda yalnızca bir satır çalıştırılır. Yukarıda verilen örnek kodda önce yöntem1, ardından yöntem2 terminale kaydedilir.

Engelleme Dili Olarak Javascript

Senkronize bir dil olan javascript'in engelleme işlevi vardır. Devam eden bir sürecin tamamlanması ne kadar sürerse sürsün, bir önceki süreç tamamlanmadan yeni bir süreç başlatılmayacaktır. Yukarıdaki kod örneğinde, yöntem1'de çok fazla kod komut dosyası bulunduğunu varsayalım. Ne kadar zaman alırsa alsın, 10 saniye veya bir dakika, yöntem2'nin yöntem1'deki tüm kod çalıştırılana kadar yürütülmeyeceğini varsayalım.

Kullanıcılar internette gezinirken bu durumla karşılaşmış olabilir. Bir web uygulaması arka uçtaki bir tarayıcıda çalıştırıldığında, büyük miktarda kod yürütülür, böylece kullanıcıya kontrol erişimini geri vermeden önce tarayıcı bir süre donmuş gibi görünür. Bu davranışa engelleme adı verilir. Tarayıcı, mevcut istek işlenene kadar başka gelen istekleri kabul edemez.

Javascript tek iş parçacıklı bir dildir

Javascript'te bir programı çalıştırmak için iş parçacığı işlevi kullanılır. İş parçacığı aynı anda yalnızca bir görevi gerçekleştirebilir. Diğer programlama dilleri çoklu iş parçacığını destekler ve birden fazla görevi paralel olarak çalıştırabilir; javascript, herhangi bir kod betiğini yürütmek için yalnızca bir iş parçacığı içerir.

Javascript'te bekleniyor

Bu bölümdeki isminden de anlaşılacağı gibi ilerlemek için talebimizin işleme alınmasını beklemek zorundayız. Bekleme, başka bir isteğin yerine getirilmediği birkaç dakika sürebilir. Eğer kod betiği beklemeden ilerlerse kod bir hatayla karşılaşacaktır. Kodu eşzamansız hale getirmek için bazı işlevlerin Javascript'te veya daha spesifik olarak Node.js'de uygulanması gerekir.

Artık Javascript'in farklı yönlerini anladığımıza göre, bazı basit örneklerle senkron ve asenkron durumu anlayalım.

Javascript'te kodun senkronize yürütülmesi

Senkron, kodun sırayla veya daha basit bir şekilde yukarıdan başlayarak satır satır aşağıya doğru adım adım yürütülmesi anlamına gelir.

Aşağıda anlaşılmasına yardımcı olabilecek bir örnek verilmiştir:

// uygulama.js

konsol. kayıt ( 'Bir' )

konsol. kayıt ( 'İki' )

konsol. kayıt ( 'Üç' )

Bu kodda, her biri bir şey yazdıran üç console.log ifadesi vardır. Öncelikle konsolda “One” yazdıracak olan ilk ifade 1 ms (tahmini) boyunca çağrı yığınına gönderilir ve terminale loglanır. Bundan sonra, ikinci ifade çağrı yığınına gönderilir ve öncekinden bir tanesi eklenerek süre 2 ms olur ve ardından konsola 'İki' kaydedilir. Son olarak, son ifade çağrı yığınına aktarılır, şimdilik süre 3 ms'dir ve konsolda 'Üç' olarak kaydedilir.

Yukarıdaki kod aşağıdaki komut çağrılarak çalıştırılabilir:

düğüm uygulaması. js

Çıktı

Yukarıda işleyişi detaylı olarak anlatılmış ve bu dikkate alınarak çıktının konsola göz açıp kapayıncaya kadar kaydedilmesi sağlanmıştır:

Javascript'te kodun eşzamansız yürütülmesi

Şimdi geri aramaları tanıtarak ve kodu eşzamansız hale getirerek aynı kodu yeniden düzenleyelim. Yukarıdaki kod şu şekilde yeniden düzenlenebilir:

// uygulama.js
printOne işlevi ( geri çağırmak ) {
setTimeout ( işlev ( ) {
konsol. kayıt ( 'Bir' ) ;
geri çağırmak ( ) ;
} , 1000 ) ;
}
printTwo işlevi ( geri çağırmak ) {
setTimeout ( işlev ( ) {
konsol. kayıt ( 'İki' ) ;
geri çağırmak ( ) ;
} , 2000 ) ;
}
işlev yazdırmaÜç ( ) {
setTimeout ( işlev ( ) {
konsol. kayıt ( 'Üç' ) ;
} , 3000 ) ;
}
konsol. kayıt ( 'Programın başlangıcı' ) ;
baskıBir ( işlev ( ) {
baskıİki ( işlev ( ) {
baskıÜç ( ) ;
} ) ;
} ) ;
konsol. kayıt ( 'Programın sonu' ) ;

Yukarıdaki bu kodda:

  • “Bir”, “İki” ve “Üç”ü yazdırmak için üç işlev bildirilir; her işlevin, kodun sıralı olarak yürütülmesine izin veren bir geri çağırma parametresi vardır.
  • setTimeout işlevi kullanılarak bir zaman aşımı ayarlanır ve belirli bir gecikmeden sonra yazdırmak için bir console.log ifadesi bulunur.
  • Programın başlangıcını ve bitişini belirten “Programın Başlangıcı” ve “Programın Sonu” olmak üzere iki mesaj basılıdır.
  • Program, “Programın Başlangıcı” yazdırılarak başlar, ardından printOne işlevi 1 saniyelik bir gecikmeyle yürütülür, ardından printTwo işlevi 2 saniyelik bir gecikmeyle yürütülür ve son olarak printThree işlevi 3 saniyelik bir gecikmeyle yürütülür. gecikme.
  • Program, Bir, İki ve Üç'ü yazdırmadan önce “Programın Sonu” ifadesini kaydeden setTimeouts işlevleri içindeki eşzamansız kod yürütmelerini beklemez.

Çıktı

Terminalde bu komutu çalıştırarak yukarıdaki kodu çalıştırın:

düğüm uygulaması. js

Artık terminaldeki çıktı eşzamansız olarak şu şekilde görünecektir:

Artık eşzamanlı ve eşzamansız yürütmeyi tam olarak anladığımıza göre, Node.js'deki olay döngüsü kavramımızı sağlamlaştırmaya geçelim.

Node.js: Olay Döngüsü Mekanizması

Hem senkronize hem de senkronize olmayan görevlerin yürütülmesi, Node.js'deki olay döngüsü tarafından yönetilir. Yürütme, Node.js projesi başlatılır başlatılmaz başlatılır ve karmaşık görevleri sorunsuz bir şekilde sisteme aktarır. Bu, diğer görevlerin ana iş parçacığında sorunsuz bir şekilde çalışabilmesini sağlar.

Node.js'de Olay Döngüsünün Görsel Açıklaması

Node.js'de olay döngüsü sürekli ve yarı sonsuzdur. Olay döngüsü, Node.js kod betiğinin başlatılmasıyla çağrılır ve eşzamansız API çağrıları yapmaktan ve süreçleri çağırmaktan sorumludur.Tick() ve zamanlayıcıları planlamak, ardından olay döngüsünün yürütülmesine devam etmek.

Node.js'de geri aramaları beş ana kuyruk türü yönetir:

  • Yaygın olarak min-heap olarak bilinen 'Zamanlayıcı Kuyruğu', 'setTimeout' ve 'setInterval' ile ilişkili geri aramaların işlenmesinden sorumludur.
  • “fs” ve “http” modüllerindeki gibi asenkron işlemlere yönelik geri aramalar “I/O Queue” tarafından gerçekleştirilir.
  • 'Kontrol Kuyruğu', Node.js'ye özgü olan 'setImmediate' işlevi için geri aramaları içerir.
  • 'Kapatma Kuyruğu' herhangi bir eşzamansız görevin kapanış olayıyla ilişkili geri aramaları yönetir.
  • Son olarak “Mikro Görev” kuyruğunda iki farklı kuyruk bulunmaktadır:
    • 'NextTick' kuyruğu, 'process.nextTick' işleviyle ilişkili geri aramaları içerir.
    • “Promise” sırası, yerel Promise ile ilgili geri aramaları kontrol eder.

Node.js'de Olay Döngüsü işlevi

Olay döngüsü, geri arama yürütme sırasını kontrol eden özel gereksinimler altında çalışır. İşlemin başlangıcında kullanıcının senkronize Javascript koduna öncelik verilir, böylece olay döngüsü yalnızca çağrı yığını temizlendiğinde başlar. Aşağıdaki yürütme sırası yapılandırılmış bir modeli izler:

En yüksek öncelik, mikro görev kuyruğundaki geri aramalara verilir, daha sonra nextTick kuyruğundaki görevlerin yürütülmesine ve ardından Promise kuyruğundaki görevlerin yürütülmesine geçilir. Zamanlayıcının kuyruk geri aramalarındaki işlemler daha sonra ele alınır ve ardından her zamanlayıcı geri aramasından sonra mikro görev kuyruğu yeniden ziyaret edilir. G/Ç, kontrol ve kapatma kuyruklarındaki geri aramalar, her aşamadan sonra ziyaret edilen mikro görev kuyruğuna benzer şekilde yürütülür.

İşlenecek daha fazla geri arama varsa döngü yürütülmeye devam eder. Kod betiği sona erdiğinde veya işlenecek geri arama kalmadığında olay döngüsü verimli bir şekilde sona erer.

Artık Etkinlik döngüsünü derinlemesine anladığımıza göre, özelliklerine bakalım.

Node.js'deki olay döngüsünün özellikleri

Ana özellikler şunlardır:

  • Olay döngüsü sonsuz bir döngü olup görevleri alır almaz yürütmeye devam eder ve görev olmadığında uyku moduna geçer ancak görev alınır alınmaz çalışmaya başlar.
  • Olay kuyruğundaki görevler yalnızca yığın boş olduğunda yürütülür, bu da etkin bir işlem olmadığı anlamına gelir.
  • Olay döngüsünde geri aramalar ve sözler kullanılabilir.
  • Olay döngüsü Soyut veri tipi kuyruğu prensibini takip ettiğinden, ilk görevi yerine getirir ve ardından bir sonrakine geçer.

Olay döngüsünün ve eşzamansız ve eşzamanlı yürütmelerin mantığının tam olarak anlaşılmasından sonra, farklı aşamaların anlaşılması, olay döngüsü kavramlarını sağlamlaştırabilir.

Node.js Olay Döngüsü Aşamaları

Yukarıda belirtildiği gibi olay döngüsü yarı sonsuzdur. Birçok aşaması vardır ancak bazı aşamalar dahili işleme için kullanılır. Bu aşamaların kod betiği üzerinde herhangi bir etkisi yoktur.

Olay döngüsü, Kuyruğun işlevselliğini takip eder ve görevi ilk giren ve ilk çıkar ilkesine göre yürütür. Zamanlanmış zamanlayıcılar, süreleri dolana kadar işletim sistemi tarafından işlenecektir. Süresi dolan zamanlayıcılar daha sonra zamanlayıcılar için geri arama kuyruğuna eklenir.

Olay döngüsü, daha fazla görev kalmayana veya izin verilen maksimum görev sayısına ulaşana kadar zamanlayıcı kuyruğundaki görevleri birer birer yürütür. Aşağıdaki bölümlerde olay döngülerinin temel aşamaları açıklanmaktadır.

Zamanlayıcılar Aşaması

Node.js'de gelecekte yürütülecek işlevleri planlayabilen bir zamanlayıcı API'si vardır. Tahsis edilen süre geçtikten sonra zamanlayıcı geri araması, planlanabildiği anda yürütülür; ancak işletim sistemi tarafından veya diğer geri aramaların yürütülmesi nedeniyle bir gecikme yaşanabilir.

Zamanlayıcılar API'sinin üç ana işlevi vardır:

  • setTimeout
  • setHemen
  • setInterval

Yukarıda belirtilen işlevler senkronizedir. Olay döngüsündeki zamanlayıcı aşamasının kapsamı setTimeout ve setInterval işlevleriyle sınırlıdır. Check işlevi setImmediate işlevini yönetirken.

Teorik kısmı sağlamlaştırmak için basit bir örnek ele alalım:

// uygulama.js

fonksiyon gecikmeliFonksiyon ( ) {

konsol. kayıt ( 'gecikmeli işlev zaman aşımından sonra yürütülür' ) ;

}

konsol. kayıt ( 'Programın başlangıcı' ) ;

setTimeout ( gecikmeliFonksiyon, 2000 ) ;

konsol. kayıt ( 'Programın sonu' ) ;

Bu kodda:

  • Program, “Programın Başlangıcı” ifadesinin terminale kaydedilmesiyle başlar.
  • Daha sonra, 2ms'lik bir zamanlayıcı ile gecikmeliFunction çağrılır, kod betiği durmaz ve arka planda gecikmeyi işlemeye devam eder.
  • İlk ifadeden sonra “Programın Sonu günlüğe kaydedilir.
  • 2ms'lik bir gecikmeden sonra, gecikmeliFunction'daki ifade terminale kaydedilir.

Çıktı

Çıktı şu şekilde görünecektir:

GecikmeliFunction'ın işlemesi için kodun durdurulmadığı görülebilir; ileri doğru hareket eder ve gecikmeden sonra işlev geri çağrısı işlenir.

Bekleyen Geri Aramalar

Olay döngüsü, yoklama aşamasında dosyaların okunması, ağ etkinlikleri veya giriş/çıkış görevleri gibi meydana gelen olayları kontrol eder. Node.js'de bu yoklama aşamasında yalnızca bazı olayların ele alındığını bilmek önemlidir. Ancak olay döngüsünün sonraki yinelemesinde bazı olaylar bekleme aşamasına ertelenebilir. Bu, karmaşık olay odaklı işlemleri içeren Node.js kodunu optimize ederken ve sorun giderirken akılda tutulması gereken önemli bir kavramdır.

Geri aramaları bekleme aşamasında, olay döngüsünün, ertelenen olayları bekleyen geri aramaların kuyruğuna eklediğini ve bunları gerçekleştirdiğini anlamak önemlidir. Bu aşama aynı zamanda belirli işletim sistemlerindeki ECONNREFUSED hata olayları gibi sistemin oluşturduğu bazı TCP soket hatalarını da ele alır.

Konsepti sağlamlaştırmak için aşağıda bir örnek verilmiştir:

// uygulama.js
yapı fs = gerekmek ( 'f' ) ;
readFileAsync işlevi ( filePath, geri arama ) {
fs. Dosyayı oku ( './PromiseText.txt' , 'utf8' , işlev ( hata, veri ) {
eğer ( hata ) {
konsol. hata ( ' Hata dosya okuma : $ { hata. İleti } ' ) ;
} başka {
konsol. kayıt ( ' Dosya içerik : $ { veri } ' ) ;
}
geri çağırmak ( ) ;
} ) ;
}
konsol. kayıt ( 'Programın başlangıcı' ) ;
readFileAsync ( './PromiseText.txt' , işlev ( ) {
konsol. kayıt ( 'Dosya okuma geri araması yürütüldü' ) ;
} ) ;
konsol. kayıt ( 'Programın sonu' ) ;

Bu kodda:

  • Program, terminalde “Programın Başlatılması” ifadesinin kaydedilmesiyle başlatılır.
  • ReadFileAsync, “PromiseText.txt” dosyasının içeriğini okumak için eşzamansız olarak tanımlanır. Dosya okunduktan sonra geri çağırma işlevini yürüten parametreli bir işlevdir.
  • Dosya okuma işlemini başlatmak için readFileAsync işlevi çağrılır.
  • Dosya okuma sürecinde program durmaz; bunun yerine bir sonraki ifadeye geçer ve onu “Programın Sonu” terminaline kaydeder.
  • Eşzamansız dosya okuma olayı, olay döngüsü tarafından arka planda işlenir.
  • Dosya eşzamansız olarak okunduktan ve içerik terminale kaydedildikten sonra program, dosya içeriğini terminale kaydeder. Bundan sonra, aşağıdaki “Dosya okuma geri araması yürütüldü” mesajını günlüğe kaydeder.
  • Olay döngüsü bir sonraki aşamada bekleyen geri arama işlemlerini yönetir.

Çıktı

Yukarıdaki yürütmenin sonucu:

Boşta, Node.js'de Hazırlık Aşaması

Boşta kalma aşaması, Node.js'deki dahili işlevlerle ilgilenmek için kullanıldığından standart bir aşama değildir. Kod betiğini etkilemez. Boşta kalma aşaması, arka planda düşük öncelikli görevlerin yönetildiği olay döngüsü için bir mola süresi gibidir. Bu aşamayı anlamak için basit bir örnek:

yapı { Boşta } = gerekmek ( 'boşta-gc' ) ;

Boşta. görmezden gelmek ( ) ;

Bu kodda rölanti fazının göz ardı edilmesini sağlayan “idle-gc” modülü kullanılmıştır. Bu, olay döngüsünün meşgul olduğu ve arka plan görevlerinin gerçekleştirilmediği durumların ele alınmasına yarar. İdde.ignore kullanımı, performans sorunlarına neden olabileceğinden optimal olarak kabul edilmez.

Node.js'de yoklama aşaması

Node.js'deki anket aşaması şu şekilde çalışır:

  • Anket kuyruğundaki olayları yönetir ve bunlara karşılık gelen görevleri gerçekleştirir.
  • Süreçteki I/O işlemlerini beklemek ve kontrol etmek için ne kadar zaman harcanacağına karar verir.

Bir zamanlayıcının bulunmaması nedeniyle olay döngüsü yoklama aşamasına girdiğinde aşağıdaki görevlerden biri gerçekleştirilecektir:

  • Node.js'deki olay döngüsünün yoklama aşamasında, bekleyen G/Ç olayları kuyruğa alınır ve ardından kuyruk boşalana kadar İlk Giren ve İlk Çıkar prensibini izleyen sıralı bir prosedürle yürütülür. Geri aramaların yürütülmesi sırasında nextTick ve mikro görev kuyrukları da etkindir. Bu, sorunsuzluğu sağlar ve G/Ç işlemlerinin daha verimli ve güvenilir bir şekilde gerçekleştirilmesine olanak tanır.
  • Kuyruk boşsa ve komut dosyası setImmediate() işlevi tarafından planlanmamışsa olay döngüsü sona erecek ve bir sonraki aşamaya (kontrol) geçecektir. Öte yandan, eğer komut dosyası zamanlaması setImmediate() işlevi tarafından yapıldıysa, olay döngüsü, geri çağrıların kendisi tarafından yürütülecek kuyruğa eklenmesine izin verir.

Bu en iyi şekilde basit bir kod örneğiyle gösterilmektedir:

setTimeout ( ( ) => {

konsol. kayıt ( 'Asenkron işlem tamamlandı' ) ;

} , 2000 ) ;

konsol. kayıt ( 'Başlangıç' ) ;

setHemen ( ( ) => {

konsol. kayıt ( 'setImmediate geri arama yürütüldü' ) ;

} ) ;

konsol. kayıt ( 'Son' ) ;

Bu kodda:

  • İki mesaj “Başlat” ve “Son” programın başlatıldığını ve sonlandırıldığını gösterir.
  • setTimeout() işlevi, 2 ms gecikmeli bir geri çağırma işlevi ayarlar ve 'Async işleminin tamamlandığını' terminale kaydeder.
  • setImmediate() işlevi, Başlat mesajı terminale kaydedildikten sonra 'setImmediate geri arama yürütüldü' mesajını terminale kaydeder.

Çıktı

Çıktı, 'Async işleminin tamamlandığını' ve 'Son' mesajından sonra yazdırıldığını yalnızca bir dakikalık gözlemle gösteren mesajları gösterecektir:

Node.js Kontrol Aşaması

Anket aşaması yürütüldükten sonra kontrol aşamasındaki geri aramalar yürütülür. Bir kod betiği setImmediate() işlevi kullanılarak zamanlanmışsa ve yoklama işlevi boşsa, olay döngüsü boşta kalmak yerine doğrudan kontrol aşamasına geçerek çalışır. setImmediate() işlevi, olay döngüsünün farklı aşamaları sırasında çalışan benzersiz bir zamanlayıcıdır.

Libuv API'si, yoklama aşaması yürütmesi tamamlandıktan sonra geri arama yürütmelerini planlamak için kullanılır. Kodun yürütülmesi sırasında olay döngüsü, gelen bağlantı isteklerini beklediği yoklama aşamasına girer. Başka bir durumda, geri arama setImmediate() işlevi kullanılarak planlanmışsa ve yoklama aşaması herhangi bir etkinlik olmadan sonlandırılırsa, beklemek yerine kontrol aşamasına geçilecektir. Anlamak için aşağıdaki örneği inceleyin:

// uygulama.js

konsol. kayıt ( 'Başlangıç' ) ;

setHemen ( ( ) => {

konsol. kayıt ( 'Derhal geri ara' ) ;

} ) ;

konsol. kayıt ( 'Son' ) ;

Bu kodda terminalde üç mesaj oturum açılmıştır. setImmediate() işlevi daha sonra son olarak 'mesajını günlüğe kaydetmek için bir geri arama gönderir' Anında geri arama ” terminale.

Çıktı

Yukarıdaki kodun çıktısı aşağıdaki sırayla görünecektir:

Node.js geri aramaları kapatır

Node.js, olayları kapatmak ve bir olay döngüsü yinelemesini sonlandırmak amacıyla geri çağrıları çalıştırmak için bu kapatma aşamasını kullanır. Bağlantı kapatıldıktan sonra olay döngüsü bu aşamadaki kapanış olaylarını yönetir. Olay döngüsünün bu aşamasında “nextTick()” ve mikro görevler diğer aşamalara benzer şekilde oluşturulur ve işlenir.

Process.exit fonksiyonu olay döngüsünü herhangi bir anda sonlandırmak için kullanılır. Olay döngüsü, bekleyen eşzamansız işlemleri göz ardı edecek ve Node.js işlemi sonlandırılacaktır.

Göz önünde bulundurulması gereken basit bir örnek:

// uygulama.js
yapı açık = gerekmek ( 'açık' ) ;
yapı sunucu = açık. CreateServer ( ( priz ) => {
priz. Açık ( 'kapalı' , ( ) => {
konsol. kayıt ( 'Soket kapalı' ) ;
} ) ;
priz. Açık ( 'veri' , ( veri ) => {
konsol. kayıt ( 'Alınan veri:' , veri. toString ( ) ) ;
} ) ;
} ) ;
sunucu. Açık ( 'kapalı' , ( ) => {
konsol. kayıt ( 'Sunucu kapalı' ) ;
} ) ;
yapı liman = 3000 ;
sunucu. Dinlemek ( liman, ( ) => {
konsol. kayıt ( `Sunucu $ bağlantı noktasını dinliyor { liman } ' ) ;
} ) ;
setTimeout ( ( ) => {
konsol. kayıt ( 'Sunucu 10 saniye sonra kapatılıyor' ) ;
sunucu. kapalı ( ) ;
işlem. çıkış ( ) ;
} , 10000 ) ;

Bu kodda:

  • const net = require('net') ” TCP sunucusunu yönetmek için gereken net modülünü içe aktarır ve “ const sunucu = net.createServer((socket) => { ” yeni bir TCP sunucusu örneği oluşturur.
  • soket.on('kapat', () => {… } tüm prizlerdeki “kapat” sesini dinler. Soket bağlantısı kapatıldığında terminale “Soket Kapalı” mesajı kaydedilir.
  • soket.on('veri', (veri) => {} ”, tüm ayrı yuvalardan gelen verileri kontrol eder ve “.toString()” işlevini kullanarak yazdırır.
  • server.on('kapat', () => {…} ”, sunucunun kendisinde “close” olayını kontrol eder ve sunucu bağlantısı kapatıldığında terminale “Sunucu Kapalı” mesajını kaydeder.
  • sunucu.dinle(bağlantı noktası, () => {…} ” bağlantı noktasına gelen bağlantıları dinler.
  • setTimeout(() => {…} ”, sunucuyu kapatmak için 10 ms'lik bir zamanlayıcı ayarlar.

Node.js'deki olay döngüsünün çeşitli aşamalarına ilişkin tartışma böylece sona eriyor. Bir sonuca varmadan önce, Node.js'de olay döngüsünden nasıl çıkılacağı olan son bir konuyu tartışalım.

Node.js'de Olay Döngüsünden Çıkma

Olay döngüsü, olay döngüsü aşamalarının tüm kuyruklarında bazı görevler olduğu sürece yürütme aşamasındadır. Olay döngüsü, çıkış aşaması yayınlandıktan sonra sona erer ve kuyrukta başka görev yoksa çıkış dinleyicisi geri çağrısı geri döner.

Bir olay döngüsünü sonlandırmanın açık yolu “.exit” yöntemini kullanmaktır. Node.js'nin aktif işlemleri, proses.exit fonksiyonu çağrıldığı anda anında sonlandırılacaktır. Planlanan ve bekleyen tüm etkinlikler iptal edilecek:

işlem. Açık ( 'çıkış' , ( kod ) => {

konsol. kayıt ( `Çıkış koduyla çıkılıyor : $ { kod } ' ) ;

} ) ;

işlem. çıkış ( 1 ) ;

Kullanıcılar .exit işlevini dinleyebilir. Node.js programı bu olayı dinlediği anda çıkış yapacağı için “.exit” fonksiyonunun senkronize olması gerektiğini belirtelim.

Bu, olay döngüsü hakkındaki tartışmayı sonlandırıyor. Olay döngüsüyle ilgili tüm kavramları, aşamaları ve örnekleri kapsayan ayrıntılı bir makale.

Çözüm

Olay döngüsünü anlamadan önce, eşzamanlı ve eşzamansız kavramlara genel bir bakış, olay döngüsündeki kod akışının anlaşılmasına yardımcı olabilir. Eşzamanlı yürütme, adım adım yürütme anlamına gelirken, eşzamansız yürütme, bazı adımların tamamlanmasını beklemeden durdurulması anlamına gelir. Makalede olay döngüsünün işleyişi tüm aşamalarıyla birlikte uygun örneklerle ele alınmaktadır.