למרות ש-Javascript היא שפה עם חוט יחיד, Node.js יכול להקצות משימות למערכת ההפעלה, מה שמאפשר לה לעבד משימות מרובות בו-זמנית. יש להשלים מספר משימות בו-זמנית מכיוון שפעולות במערכת ההפעלה הן רב-הליכיות. ההתקשרות חזרה המשויכת לכל פעולה מתווספת לתור האירועים ומתוזמנת על ידי Node.js לפעול כאשר המשימה שצוינה תושלם.
כדי לכתוב קוד Node.js יעיל ואמין, על המשתמש להיות בעל הבנה מוצקה של לולאות אירועים. זה גם יכול לעזור בפתרון בעיות ביצועים בצורה יעילה. לולאת האירועים ב-Node.js חוסכת זיכרון ומאפשרת לך לעשות מספר דברים בבת אחת מבלי שתצטרך לחכות עד שכל אחד מהם יסתיים. המונח 'אסינכרוני' מתייחס לכל פונקציית Javascript שפועלת ברקע מבלי לחסום בקשות נכנסות.
לפני שקפוץ ישירות ללולאות אירועים, בואו נסתכל על היבטים שונים של שפת התכנות Javascript.
Javascript כשפת תכנות אסינכרונית
הבה נבחן את המושגים של תכנות אסינכרוני. Javascript משמש ביישומי אינטרנט, ניידים ושולחן העבודה, אך יש לציין ש-Javascript היא שפת תכנות מחשב סינכרונית עם חוט יחיד.
ניתנת דוגמה פשוטה לקוד כדי להבין את המושג.
שיטת פונקציה 1 ( ) {
לְנַחֵם. עֵץ ( 'פונקציה 1' )
}
שיטת פונקציה2 ( ) {
לְנַחֵם. עֵץ ( 'פונקציה 2' )
}
שיטה 1 ( )
שיטה 2 ( )
בקוד זה נוצרות שתי פונקציות פשוטות ו-method1 נקראת תחילה, כך שהיא תירשם תחילה את method1 ואז תעבור לשנייה.
תְפוּקָה
Javascript כשפת תכנות סינכרונית
Javascript היא שפת תכנות סינכרונית ומבצעת כל שורה צעד אחר צעד נע מלמעלה למטה כשרק שורה אחת מבוצעת בכל פעם. בדוגמה הקודמת לעיל, method1 נרשם תחילה בטרמינל ולאחר מכן השיטה2.
Javascript כשפת חסימה
להיות JavaScript בשפה סינכרונית יש פונקציונליות חסימה. זה לא משנה כמה זמן לוקח להשלים תהליך מתמשך, אבל תהליך חדש לא יתחיל עד שהקודם יושלם. בדוגמה של הקוד לעיל נניח שיש הרבה סקריפט קוד ב-method1, לא משנה כמה זמן זה ייקח או 10 שניות או דקה מתודה2 לא יבוצע עד שכל הקוד ב-method1 יבוצע.
ייתכן שמשתמשים חוו זאת במהלך הגלישה. כאשר אפליקציית אינטרנט מופעלת בדפדפן בקצה האחורי, מופעל גוש ענק של קוד כך שהדפדפן נראה קפוא לזמן מה לפני החזרת גישת הבקרה למשתמש. התנהגות זו ידועה בשם חסימה. הדפדפן לא יכול לקבל בקשות נכנסות נוספות עד שהבקשה הנוכחית תעובד.
Javascript היא שפה עם חוט יחיד
כדי להפעיל תוכנית ב-javascript נעשה שימוש בפונקציונליות השרשור. חוטים מסוגלים לבצע משימה אחת בלבד בכל פעם. שפות תכנות אחרות תומכות בריבוי שרשורים ויכולות להריץ משימות מרובות במקביל, javascript מכיל רק שרשור אחד לביצוע כל סקריפט קוד.
ממתין ב-Javascript
כפי שעולה מהשם בסעיף זה, עלינו להמתין לעיבוד בקשתנו כדי להמשיך הלאה. ההמתנה עשויה להימשך מספר דקות ובמהלכן לא מתקבלת בקשה נוספת. אם סקריפט הקוד ימשיך ללא המתנה, הקוד יתקל בשגיאה. יש ליישם פונקציונליות מסוימת ב-Javascript או ליתר דיוק Node.js כדי להפוך את הקוד לא-סינכרוני.
כעת, לאחר שהבנו את ההיבטים השונים של Javascript, הבה נבין את הסינכרוני והאסינכרוני באמצעות כמה דוגמאות פשוטות.
ביצוע סינכרוני של קוד ב-Javascript
סינכרוני פירושו שהקוד מבוצע ברצף או יותר פשוט שלב אחר שלב החל מלמעלה ונע למטה שורה אחר שורה.
להלן דוגמה שיכולה לעזור להבין:
// application.jsלְנַחֵם. עֵץ ( 'אחד' )
לְנַחֵם. עֵץ ( 'שתיים' )
לְנַחֵם. עֵץ ( 'שְׁלוֹשָׁה' )
בקוד הזה, יש שלוש הצהרות console.log שכל אחת מהן מדפיסה משהו. ראשית ההצהרה הראשונה שעומדת להדפיס 'One' במסוף נשלחת לערימת השיחות למשך 1 ms (משוער) ואז היא נרשמת למסוף. לאחר מכן, ההצהרה השנייה נדחפת לערימת השיחות ועכשיו השעה היא 2 אלפיות השנייה עם אחד נוסף מהקודם ואז הוא רושם 'שניים' לקונסולה. לבסוף, ההצהרה האחרונה נדחפת לערימת השיחות לעת עתה השעה היא 3ms והיא מתעדת 'שלוש' בקונסולה.
ניתן להפעיל את הקוד לעיל על ידי הפעלת הפקודה הבאה:
יישום צומת. jsתְפוּקָה
התפקוד מוסבר לעיל בפירוט ועל ידי התחשבות בו הפלט נרשם לקונסולה בהרף עין:
ביצוע אסינכרוני של קוד ב-Javascript
כעת תנו לנו לשחזר את אותו קוד על ידי הצגת התקשרויות חוזרות והפיכת הקוד לא-סינכרוני. הקוד לעיל יכול להיות משוחזר כ:
// application.jsפונקציה printOne ( התקשר חזרה ) {
setTimeout ( פוּנקצִיָה ( ) {
לְנַחֵם. עֵץ ( 'אחד' ) ;
התקשר חזרה ( ) ;
} , 1000 ) ;
}
פונקציה printTwo ( התקשר חזרה ) {
setTimeout ( פוּנקצִיָה ( ) {
לְנַחֵם. עֵץ ( 'שתיים' ) ;
התקשר חזרה ( ) ;
} , 2000 ) ;
}
פונקציה printThree ( ) {
setTimeout ( פוּנקצִיָה ( ) {
לְנַחֵם. עֵץ ( 'שְׁלוֹשָׁה' ) ;
} , 3000 ) ;
}
לְנַחֵם. עֵץ ( 'תחילת התוכנית' ) ;
printOne ( פוּנקצִיָה ( ) {
הדפס שני ( פוּנקצִיָה ( ) {
הדפס שלוש ( ) ;
} ) ;
} ) ;
לְנַחֵם. עֵץ ( 'סוף התוכנית' ) ;
בקוד זה למעלה:
- שלוש פונקציות מוכרזות להדפיס 'One', 'Two' ו-'Three', לכל פונקציה יש פרמטר Callback המאפשר ביצוע רציף של קוד.
- פסק זמן מוגדר באמצעות הפונקציה setTimeout ויש הצהרת console.log להדפסה לאחר עיכוב מסוים.
- שתי הודעות מודפסות 'התחלת התוכנית' ו'סוף התוכנית' המציינות את ההתחלה והסיום של התוכנית.
- התוכנית מתחילה בהדפסת 'התחלת התוכנית' שלאחריה מופעלת הפונקציה printOne בהשהייה של 1 שנייה, לאחר מכן מופעלת הפונקציה printTwo בהשהיה של 2 שניות, ולבסוף הפונקציה printThree מבוצעת בהשהיה של 3 שניות לְעַכֵּב.
- התוכנית לא ממתינה לביצועי הקוד האסינכרוני בתוך פונקציות setTimeouts אשר רושמות את הצהרת 'סוף התוכנית' לפני הדפסת אחת, שתיים ושלוש.
תְפוּקָה
הפעל את הקוד לעיל על ידי ביצוע פקודה זו בטרמינל:
יישום צומת. jsכעת הפלט במסוף יופיע באופן אסינכרוני כ:
כעת, לאחר שיש לנו הבנה מלאה של הביצוע הסינכרוני והאסינכרוני, בואו נקפוץ לחיזוק הרעיון שלנו של לולאת אירועים ב-Node.js.
Node.js: מנגנון לולאת אירועים
הביצוע של משימות סינכרוניות וגם אסינכרוניות מנוהל על ידי לולאת האירועים ב-Node.js. הביצוע מופעל ברגע שהפרויקט Node.js יוצא לדרך ומעביר בצורה חלקה את המשימות המורכבות למערכת. זה מבטיח שמשימות אחרות יכולות לפעול בצורה חלקה בשרשור הראשי.
הסבר חזותי של Event Loop ב-Node.js
לולאת האירועים היא רציפה ואינסופית למחצה ב-Node.js. לולאת האירועים מופעלת על ידי התחלת סקריפט הקוד של Node.js, והיא אחראית על ביצוע קריאות API אסינכרון ותהליכי שיחות.Tick(), וטיימרים לתזמון ימשיכו את ביצוע לולאת האירועים.
ב-Node.js, חמישה סוגים עיקריים של תורים מטפלים בהתקשרות חוזרת:
- 'תור הטיימר' הידוע בדרך כלל כ-min-heap אחראי לטיפול בהתקשרויות חוזרות הקשורות ל-'setTimeout' ו-'setInterval'.
- ההתקשרות לאחור עבור פעולות אסינכרוניות כמו במודולים 'fs' ו- 'http' מטופלות על ידי 'תור I/O'.
- ה-'Check Queue' מכיל התקשרויות לפונקציה 'setImmediate' שהיא ייחודית ל-Node.
- 'תור סגור' מנהל שיחות חוזרות הקשורות לאירוע סגירה של כל משימה אסינכרונית.
- לבסוף, ישנם שני תורים שונים בתור 'Micro Task':
- תור 'nextTick' מכיל התקשרויות חוזרות המשויכות לפונקציה 'process.nextTick'.
- תור 'הבטחה' שולט בהתקשרויות חוזרות הקשורות להבטחה מקורית.
פונקציונליות Event Loop ב-Node.js
לולאת האירוע מתפקדת תחת דרישות ספציפיות השולטות בצו ביצוע החזרה. קוד ה-Javascript הסינכרוני של המשתמש מקבל עדיפות בתחילת התהליך, כך שלולאת האירועים מתחילה רק כאשר מחסנית השיחות מנוקה. רצף הביצוע הבא עוקב אחר דפוס מובנה:
העדיפות הגבוהה ביותר ניתנת ל-callbacks בתור microtask ואז עוברים לביצוע המשימות בתור NextTick ואחריו המשימות בתור Promise. לאחר מכן מטופלים התהליכים בהתקשרויות התור של הטיימר, ולאחר מכן עוברים שוב לתור ה-microtask לאחר כל קריאה חוזרת של טיימר. ההתקשרויות בתורי ה-I/O, הבדיקה והסגירה מבוצעות בדפוס דומה עם תור ה-microtask שאליו ביקר לאחר כל שלב.
הלולאה ממשיכה לפעול אם יש עוד התקשרויות לעיבוד. כאשר סקריפט הקוד הסתיים או שלא נותרו התקשרויות חוזרות לעיבוד, לולאת האירוע מסתיימת ביעילות.
כעת, כשאנחנו מבינים לעומק את לולאת האירוע, בואו נסתכל על התכונות שלה.
תכונות של לולאת אירועים ב-Node.js
המאפיינים העיקריים הם:
- לולאת האירועים היא לולאה אינסופית וממשיכה לבצע את המשימות ברגע שהיא מקבלת אותן ועוברת למצב שינה למקרה שאין משימות אך מתחילה לתפקד ברגע שהמשימה מתקבלת.
- המשימות בתור האירועים מבוצעות רק כאשר המחסנית ריקה פירושו שאין פעולה פעילה.
- ניתן להשתמש בהתקשרויות והבטחות בלולאת האירוע.
- כאשר לולאת האירועים עוקבת אחר העיקרון של תור סוג נתונים מופשט, היא ממלאת את המשימה הראשונה ואז ממשיכה למשימה הבאה.
לאחר הבנה מעמיקה של לולאת האירועים, וההיגיון של ביצוע אסינכרוני וסינכרוני, הבנה של השלבים השונים עשויה לגבש את המושגים של לולאת האירועים.
Node.js Event loop Phases
כפי שהוזכר לעיל, לולאת האירועים היא חצי אינסופית. יש לו שלבים רבים אבל כמה שלבים משמשים לטיפול פנימי. לשלבים אלה אין כל השפעה על סקריפט הקוד.
לולאת האירועים עוקבת אחר הפונקציונליות של Queue ומבצעת את המשימה על פי העיקרון של נכנס ראשון ויוצא ראשון. הטיימרים המתוזמנים יטופלו על ידי מערכת ההפעלה עד שיפוג תוקפם. הטיימרים שפג תוקפם מתווספים לאחר מכן לתור ההתקשרות חזרה עבור טיימרים.
לולאת האירוע מבצעת את המשימות בתור של הטיימר בזו אחר זו עד שלא נותרו עוד משימות או שהיא מגיעה למספר המקסימלי המותר של משימות. בסעיפים למטה מוסברים שלבי הליבה של לולאות אירועים.
שלב טיימרים
ב-Node.js יש טיימר API שיכול לתזמן את הפונקציות שאמורות להתבצע בעתיד. לאחר שהזמן המוקצה חלף, ההתקשרות חוזרת של הטיימר תתבצע ברגע שניתן לתזמן אותן; עם זאת, עשוי להיות עיכוב מקצה מערכת ההפעלה או עקב ביצוע התקשרויות אחרות.
ל-API של טיימרים שלוש פונקציות עיקריות:
- setTimeout
- הגדר מיידי
- setInterval
הפונקציות שהוזכרו לעיל הן סינכרוניות. ההיקף של שלב הטיימר בלולאת האירועים מוגבל לפונקציות setTimeout ו-setInterval. בעוד שפונקציית הסימון מטפלת בפונקציה setImmediate.
הבה נשקול דוגמה פשוטה לחיזוק החלק התיאורטי:
// application.jsפונקציה delayedFunction ( ) {
לְנַחֵם. עֵץ ( 'הפונקציה המושהית מבוצעת לאחר הזמן הקצוב' ) ;
}
לְנַחֵם. עֵץ ( 'תחילת התוכנית' ) ;
setTimeout ( delayedFunction, 2000 ) ;
לְנַחֵם. עֵץ ( 'סוף התוכנית' ) ;
בקוד הזה:
- התוכנית מתחילה על ידי רישום ההצהרה 'התחלת התוכנית' למסוף.
- ואז ה-delayedFunction נקרא עם טיימר של 2ms, סקריפט הקוד לא עוצר וממשיך לטפל בעיכוב ברקע.
- ההצהרה 'סוף התוכנית נרשם אחרי ההצהרה הראשונה.
- לאחר עיכוב של 2ms, ההצהרה ב-delayedFunction נרשמת למסוף.
תְפוּקָה
הפלט יופיע כ:
ניתן לראות שהקוד לא נעצר לעיבוד delayedFunction; הוא נע קדימה ואחרי ההשהיה, החזרה לפונקציה מעובדת.
שיחות חוזרות בהמתנה
לולאת האירוע בודקת את האירועים המתרחשים, כמו קריאת קבצים, פעילויות רשת או משימות קלט/פלט, בשלב הסקרים. חשוב לדעת שב-Node.js, רק חלק מהאירועים מטופלים בשלב הסקרים הזה. עם זאת, באיטרציה שלאחר מכן של לולאת האירוע, אירועים מסוימים עשויים להידחות לשלב הממתין. זהו מושג מפתח שיש לזכור בעת אופטימיזציה ופתרון בעיות של קוד Node.js הכולל פעולות מורכבות מונעות אירועים.
חשוב להבין שבמהלך שלב ההתקשרות חוזרים ממתינים, לולאת האירועים מוסיפה אירועים נדחים לתור ההתקשרויות הממתינות ומבצעת אותם. שלב זה מטפל גם בכמה שגיאות שקע TCP שהמערכת יצרה, כגון אירועי שגיאה ECONNREFUSED במערכות הפעלה מסוימות.
להלן מוזכרת דוגמה לחיזוק המושג:
// application.jsconst fs = לִדרוֹשׁ ( 'fs' ) ;
פונקציה readFileAsync ( filePath, callback ) {
fs. readFile ( './PromiseText.txt' , 'utf8' , פונקציה ( טעות, נתונים ) {
אם ( לִטְעוֹת ) {
לְנַחֵם. שְׁגִיאָה ( ` שְׁגִיאָה קובץ קריאה : $ { לִטְעוֹת. הוֹדָעָה } ` ) ;
} אַחֵר {
לְנַחֵם. עֵץ ( ` קוֹבֶץ תוֹכֶן : $ { נתונים } ` ) ;
}
התקשר חזרה ( ) ;
} ) ;
}
לְנַחֵם. עֵץ ( 'תחילת התוכנית' ) ;
readFileAsync ( './PromiseText.txt' , פונקציה ( ) {
לְנַחֵם. עֵץ ( 'התקשרות חוזרת של קריאת קובץ בוצעה' ) ;
} ) ;
לְנַחֵם. עֵץ ( 'סוף התוכנית' ) ;
בקוד הזה:
- התוכנית מתחילה על ידי רישום ההצהרה 'התחלת התוכנית' בטרמינל.
- ה-readFileAsync מוגדר באופן אסינכרוני לקריאת תוכן הקובץ 'PromiseText.txt'. זוהי פונקציה פרמטרית שמבצעת פונקציית callback לאחר קריאת הקובץ.
- הפונקציה readFileAsync נקראת כדי להתחיל את תהליך קריאת הקבצים.
- בתהליך קריאת הקבצים, התוכנית לא עוצרת; במקום זאת, הוא ממשיך להצהרה הבאה ומתחבר למסוף 'סוף התוכנית'.
- האירוע האסינכרוני של קריאת קבצים מעובד ברקע על ידי לולאת האירוע.
- לאחר קריאת הקובץ באופן אסינכרוני והתוכן נרשם למסוף, התוכנה רושמת את תוכן הקובץ למסוף. לאחר מכן, הוא רושם את ההודעה הבאה 'התקשרות חוזרת של קריאת קובץ בוצעה'.
- לולאת האירועים מטפלת בפעולות ההתקשרות הממתינות בשלב הבא.
תְפוּקָה
התוצאה של הביצוע לעיל היא:
סרק, הכן את השלב ב-Node.js
שלב ה-Idle משמש לטיפול בפונקציות פנימיות ב-Node.js ולכן הוא אינו שלב סטנדרטי. זה לא משפיע על סקריפט הקוד. שלב הסרק הוא כמו תקופת הפסקה עבור לולאת האירוע שבמהלכה מנהלת את המשימות בעדיפות נמוכה ברקע. דוגמה פשוטה להבנת השלב הזה היא:
const { לְהִתְבַּטֵל } = לִדרוֹשׁ ( 'בטל-gc' ) ;לְהִתְבַּטֵל. להתעלם ( ) ;
בקוד זה, נעשה שימוש במודול 'idle-gc' המאפשר להתעלם משלב הסרק. זה משמש לטיפול במצבים כאשר לולאת האירועים עמוסה ומשימות רקע אינן מבוצעות. השימוש ב- idle.ignore אינו נחשב לאופטימלי מכיוון שהוא עלול לגרום לבעיות ביצועים.
שלב הסקרים ב-Node.js
שלב הסקר ב-Node.js משמש כ:
- הוא מטפל באירועים בתור הסקרים ומבצע את המשימות המתאימות להם.
- הוא מחליט כמה זמן להקדיש להמתנה ולבדוק את פעולות ה-I/O בתהליך.
כאשר לולאת האירוע נכנסת לשלב הסקר עקב היעדר טיימר תתבצע אחת מהמשימות הבאות:
- בשלב הסקר של לולאת האירועים ב-Node.js, אירועי ה-I/O הממתינים נמצאים בתור ולאחר מכן מבוצעים בהליך רציף לפי העיקרון של First In and First Out עד שהתור מתרוקן. במהלך ביצוע ההתקשרות חוזרים גם תורי nextTick ו-microtasks נמצאים בפעולה. זה מבטיח חלקות ומאפשר לטפל בפעולות I/O בצורה יעילה ואמינה יותר.
- אם התור ריק והסקריפט לא תוכנן על ידי הפונקציה setImmediate() אז לולאת האירוע תסתיים והיא תמשיך לשלב הבא (בדוק). מצד שני, אם תזמון הסקריפט נעשה על ידי הפונקציה setImmediate() לולאת האירוע מאפשרת להוסיף את ההתקשרויות לתור שיבוצעו על ידה.
זה מומחש בצורה הטובה ביותר עם דוגמה פשוטה של קוד:
setTimeout ( ( ) => {לְנַחֵם. עֵץ ( 'פעולת אסינכרון הושלמה' ) ;
} , 2000 ) ;
לְנַחֵם. עֵץ ( 'הַתחָלָה' ) ;
הגדר מיידי ( ( ) => {
לְנַחֵם. עֵץ ( 'setImmediate callback בוצע' ) ;
} ) ;
לְנַחֵם. עֵץ ( 'סוֹף' ) ;
בקוד הזה:
- שתי הודעות 'התחל' ו'סיום' מציינות את התחלת התוכנית וסיום אותה.
- הפונקציה setTimeout() מגדירה פונקציית התקשרות חוזרת בהשהייה של 2 אלפיות השנייה ורושמת את 'פעולת אסינכרון הושלמה' למסוף.
- הפונקציה setImmediate() מתעדת את הודעת 'setImmediate callback executed' למסוף לאחר שהודעת ההתחלה נרשמה למסוף.
תְפוּקָה
הפלט יציג את ההודעות עם התבוננות דקה בלבד ש'פעולת אסינכרון הושלמה' נמשכת זמן והיא מודפסת לאחר הודעת 'סיום':
Node.js בדיקת שלב
לאחר ביצוע שלב הסקר מבוצעות ההתקשרויות בשלב הבדיקה. אם סקריפט קוד מתוזמן באמצעות הפונקציה setImmediate() ופונקציית הסקר פנויה, לולאת האירוע פועלת על ידי מעבר ישירות לשלב הבדיקה במקום להישאר לא פעיל. הפונקציה setImmediate() היא טיימר ייחודי הפועל במהלך השלבים השונים של לולאת האירועים.
ה-API של libuv משמש לתכנון ביצועי ה-callback לאחר השלמת ביצוע שלב הסקר. במהלך ביצוע הקוד, לולאת האירועים נכנסת לשלב הסקר בו היא ממתינה לבקשות החיבור הנכנסות. במקרה אחר אם הקריאה לאחור מתוכננת באמצעות הפונקציה setImmediate() ושלב הסקר יסתיים ללא כל פעילות הוא יעבור לשלב הבדיקה במקום להמתין. שקול את הדוגמה הבאה להבנה:
// application.jsלְנַחֵם. עֵץ ( 'הַתחָלָה' ) ;
הגדר מיידי ( ( ) => {
לְנַחֵם. עֵץ ( 'התקשרות חזרה מיידית' ) ;
} ) ;
לְנַחֵם. עֵץ ( 'סוֹף' ) ;
בקוד זה שלוש הודעות מחוברות למסוף. הפונקציה setImmediate() לאחר מכן שולחת סוף סוף התקשרות חוזרת כדי לרשום את ההודעה ' התקשרות מיידית ' אל הטרמינל.
תְפוּקָה
הפלט של הקוד לעיל יופיע ברצף הבא:
Node.js סוגרים התקשרויות חוזרות
Node.js משתמש בשלב הסגירה הזה כדי להפעיל התקשרויות חוזרות לסגירת אירועים ולסיים איטרציה של לולאת אירועים. לאחר סגירת החיבור, לולאת האירועים מטפלת באירועי הסגירה בשלב זה. בשלב זה של לולאת האירוע, 'nextTick()' ומיקרו-משימות נוצרות ומעובדות בדומה לשלבים אחרים.
הפונקציה process.exit משמשת לסיום לולאת האירוע בכל רגע. לולאת האירוע תתעלם מכל פעולות אסינכרוניות ממתינות ותהליך Node.js יסתיים.
דוגמה פשוטה לשקול היא:
// application.jsconst נֶטוֹ = לִדרוֹשׁ ( 'נֶטוֹ' ) ;
const שרת = נֶטוֹ. createServer ( ( שֶׁקַע ) => {
שֶׁקַע. עַל ( 'סגור' , ( ) => {
לְנַחֵם. עֵץ ( 'שקע סגור' ) ;
} ) ;
שֶׁקַע. עַל ( 'נתונים' , ( נתונים ) => {
לְנַחֵם. עֵץ ( 'נתונים שהתקבלו:' , נתונים. toString ( ) ) ;
} ) ;
} ) ;
שרת. עַל ( 'סגור' , ( ) => {
לְנַחֵם. עֵץ ( 'שרת סגור' ) ;
} ) ;
const נמל = 3000 ;
שרת. להקשיב ( נמל, ( ) => {
לְנַחֵם. עֵץ ( `שרת מאזין ביציאה $ { נמל } ` ) ;
} ) ;
setTimeout ( ( ) => {
לְנַחֵם. עֵץ ( 'סגירת שרת לאחר 10 שניות' ) ;
שרת. סגור ( ) ;
תהליך. יְצִיאָה ( ) ;
} , 10000 ) ;
בקוד הזה:
- ' const net = require('net') ' מייבא את מודול הרשת הנדרש לטיפול בשרת TCP ו' const server = net.createServer((socket) => { ' יוצר מופע חדש של שרת TCP.
- ' socket.on('close', () => {… } ' מקשיב ל'סגור' על כל השקעים. כאשר חיבור השקע נסגר, ההודעה 'Socket Closed' נרשמת למסוף.
- ' socket.on('data', (data) => {} ' בודק נתונים נכנסים מכל השקעים הבודדים ומדפיס אותם באמצעות הפונקציה '.toString()'.
- ' server.on('close', () => {…} ' בודק את אירוע 'סגור' בשרת עצמו, וכאשר חיבור השרת נסגר הוא רושם את הודעת 'השרת סגור' למסוף.
- ' server.listen(port, () => {…} ” מאזין לחיבורים נכנסים ביציאה.
- ' setTimeout(() => {…} ” מגדיר טיימר של 10 אלפיות השנייה לסגירת השרת.
בכך מסתיים הדיון על השלבים השונים של לולאת האירועים ב-Node.js. לפני שנקפוץ למסקנה, בואו נדון בדבר אחרון שהוא איך לצאת מלולאת האירועים ב-Node.js.
יציאה מלולאת האירועים ב-Node.js
לולאת האירועים נמצאת בשלב הביצוע כל עוד יש כמה משימות בכל התורים של שלבי לולאת האירוע. לולאת האירוע מסתיימת לאחר שנפלט שלב היציאה והקריאה חוזרת של מאזין היציאה חוזרת אם אין עוד משימות בתורים.
הדרך המפורשת לסיים לולאת אירוע היא להשתמש בשיטת '.exit'. התהליכים הפעילים של ה-Node.js יסתיימו באופן מיידי ברגע שהפונקציה process.exit תיקרא. כל האירועים המתוכננים והממתינים יוסרו:
תהליך. עַל ( 'יְצִיאָה' , ( קוד ) => {לְנַחֵם. עֵץ ( `יוצא עם קוד יציאה : $ { קוד } ` ) ;
} ) ;
תהליך. יְצִיאָה ( 1 ) ;
משתמשים יכולים להאזין לפונקציית .exit. יש לציין שהפונקציה '.exit' חייבת להיות סינכרונית שכן תוכנית Node.js תצא ברגע שהיא מאזינה לאירוע זה.
בכך מסתיים הדיון על לולאת האירוע. מאמר מעמיק שכיסה את כל המושגים, השלבים והדוגמאות הקשורים ללופ האירוע.
סיכום
לפני הבנת לולאת האירועים, סקירה כללית של המושגים הסינכרוניים והאסינכרוניים יכולה לעזור להבין את זרימת הקוד בלולאת האירועים. ביצוע סינכרוני פירושו ביצוע שלב אחר שלב בעוד ביצוע אסינכרוני פירושו עצירת כמה שלבים מבלי להמתין לסיומם. העבודה של לולאת האירוע יחד עם כל השלבים יחד עם דוגמאות מתאימות נדונים במאמר.