תוך כדי תכנות ב' node.js ', תהליך בודד לעולם אינו יעיל להתמודדות עם עומס העבודה הגובר של האפליקציה. לכן, יכולים להיות מצבים מסוימים שבהם המפתח צריך ליצור תהליכים חדשים, לעבוד עם משימות ארוכות טווח ולאפשר אינטראקציה עם מערכת ההפעלה. ניתן להשיג זאת על ידי יצירת תהליכי צאצא כדי לעשות שימוש במספר תהליכים, ובכך לשנות את קנה המידה של יישום Node.
כתיבה זו מסבירה את התוכן הרשום להלן:
- מהו תהליך ילד?
- כיצד ליצור תהליכי צאצא ב-Node.js?
- יצירת תהליכי צאצא ב-node.js באמצעות ' לְהַשְׁרִיץ() ' שיטה.
- יצירת תהליכי צאצא ב-node.js באמצעות ' מזלג() ' שיטה.
- יצירת תהליכי צאצא ב-node.js באמצעות ' exec() ' שיטה.
- יצירת תהליכי צאצא ב-node.js באמצעות ' execFile() ' שיטה.
מהו תהליך ילד?
תהליך צאצא מתאים לתהליך שנוצר באמצעות תהליך אחר, כלומר הורה. Node.js מספק את ' תהליך_ילד מודול המבטיח תקשורת יעילה בין תהליכי הילד. כמו כן, מודול זה מסייע בהפעלת תכונות מערכת ההפעלה על ידי ביצוע כל פקודת מערכת בתוך תהליך צאצא.
כיצד ליצור תהליכי צאצא ב-Node.js?
הילד מעבד ב' node.js 'ניתן ליצור באמצעות הגישות המפורטות להלן:
- ' לְהַשְׁרִיץ() ' שיטה.
- ' מזלג() ' שיטה.
- ' exec() ' שיטה.
- ' execFile() ' שיטה.
גישה 1: יצירת תהליכי צאצא ב-node.js באמצעות שיטת 'spawn()'.
ה ' לְהַשְׁרִיץ() ' השיטה יוצרת cmdlet בתהליך חדש תוך שימוש ב-cmdlet המסופק ובארגומנטים של שורת הפקודה. המופע של ChildProcess מחיל/מייש את ה-API של EventEmitter המאפשר לרשום מטפלים לאירועים על אובייקטים צאצאים. אירועים אלה כוללים יציאה, ניתוק, שגיאה, הודעה וסגירה.
תחביר
תהליך_ילד. לְהַשְׁרִיץ ( cmdlet [ , טוען ] [ , אפשרויות ] )בתחביר הזה:
- cmdlet: צריך מחרוזת שהיא ה-cmdlet כדי לבצע.
- args: זה מתייחס לרשימת הארגומנטים של מחרוזת. ערך ברירת המחדל הוא מערך null.
- ה ' אפשרויות ' יכול להיות 'קליפה' שלוקחת ערך בוליאני. זה כזה שאם זה ' נָכוֹן ', ה-cmdlet מבוצע מתוך המעטפת. ערך ברירת המחדל הוא ' שֶׁקֶר ' מה שמרמז על שום קליפה. כברירת מחדל, ' לְהַשְׁרִיץ() ” אינו יוצר/יוצר מעטפת כדי להפעיל את ה-cmdlet ולכן, חיוני להעביר אותו כ”אופציה” תוך כדי גישה לתהליך הילד.
ערך החזרה: שיטה זו מאחזרת אובייקט ChildProcess.
להלן ההדגמה של יצירת תהליך ילד:
const { לְהַשְׁרִיץ } = לִדרוֹשׁ ( 'תהליך_ילד' ) ;const יֶלֶד = לְהַשְׁרִיץ ( 'אתה' , [ 'D: \S ETUPS' ] , { צדף : נָכוֹן } ) ;
יֶלֶד. stdout . עַל ( 'נתונים' , ( נתונים ) => {
לְנַחֵם. עֵץ ( `סטדאוט : $ { נתונים } ` ) ;
} ) ;
יֶלֶד. סטדרר . עַל ( 'נתונים' , ( נתונים ) => {
לְנַחֵם. שְׁגִיאָה ( `סטדרר : $ { נתונים } ` ) ;
} ) ;
יֶלֶד. עַל ( 'סגור' , ( קוד ) => {
לְנַחֵם. עֵץ ( `תהליך צאצא יצא עם הקוד $ { קוד } ` ) ;
} ) ;
בגוש הקוד הזה:
- קודם כל, כלול את ' תהליך_ילד מודול ליצירת תהליך צאצא.
- לאחר מכן, התחל תהליך צאצא להצגת התוכן בנתיב שצוין, כלומר ' D:\SETUPS '.
- לבסוף, ה' סגור אירוע ” מופעל כאשר כל תהליך הצאצא יוצא והודעת היציאה מוצגת במסוף.
תְפוּקָה
כאן, הפעל את ה-cmdlet הבא כדי להפעיל את הקוד ולהציג את התוכן בנתיב היעד:
טמפ' הצומת. js 
גישה 2: יצירת תהליכי צאצא ב-node.js באמצעות שיטת 'fork()'.
שיטה זו קשורה ל' לְהַשְׁרִיץ() שיטה שבה התקשורת בין תהליכי הילד וההורה יכולה להתבצע באמצעות ' לִשְׁלוֹחַ() ' שיטה.
ה ' מזלג() השיטה מפרידה את משימות החישוב המורכבות מלולאת האירוע (main). ניתן להשתמש בשיטה זו כדי לגשת לתהליכי צאצא מרובים, אך היא יכולה להשפיע על הביצועים הכוללים מכיוון שלכל תהליך יש זיכרון משלו.
תחביר
תהליך_ילד. מזלג ( mdpath [ , טוען ] [ , אפשרויות ] )לפי התחביר הזה:
- ' mdpath ” לוקח מחרוזת שמייצגת את המודול לביצוע בילד.
- ' args ' מתייחס לרשימת ארגומנטים של מחרוזת.
- ' אפשרויות ' יכול להיות 'execPath', 'env', 'CWD', 'מנותק' ו-'execArgv'.
ערך החזרה: שיטה זו מאחזרת מופע ChildProcess.
קוד (תהליך הורה)
כעת, עבור על גוש הקוד הנתון להלן המאפשר את התקשורת בין תהליכי ההורה והילד בעזרת ' לִשְׁלוֹחַ() ' שיטה:
const cp = לִדרוֹשׁ ( 'תהליך_ילד' ) ;לתת לילד = cp. מזלג ( __שם שם + '/fork2.js' ) ;
יֶלֶד. עַל ( 'הוֹדָעָה' , פונקציה ( איקס ) {
לְנַחֵם. עֵץ ( 'תהליך הורה קיבל:' , איקס ) ;
} ) ;
יֶלֶד. לִשְׁלוֹחַ ( { שלום : 'מתהליך הורה' } ) ;
יֶלֶד. עַל ( 'סגור' , ( קוד ) => {
לְנַחֵם. עֵץ ( `תהליך צאצא יצא עם הקוד $ { קוד } ` ) ;
} ) ;
בקוד הזה:
- כמו כן, שלבו את ' תהליך_ילד מודול ליצירת תהליך צאצא.
- כעת, ציין את הנתיב של תהליך הילד באמצעות ' מזלג() ' שיטה.
- לבסוף, הצג את ההודעה המייצגת את תהליך האב באמצעות ' לִשְׁלוֹחַ() ' השיטה והצג את השגיאות המתמודדות אם ישנן.
קוד (תהליך ילד)
קובץ הקוד הבא, כלומר, ' fork2.js ' מייצג את תהליך הילד ששולח גם את ההודעה באמצעות ' לִשְׁלוֹחַ() ' השיטה, כדלקמן:
תהליך. עַל ( 'הוֹדָעָה' , פונקציה ( M ) {לְנַחֵם. עֵץ ( 'תהליך הילד קיבל:' , M ) ;
} ) ;
תהליך. לִשְׁלוֹחַ ( { שלום : 'מתהליך ילד' } ) ;
תְפוּקָה
כעת, הפעל את ה-cmdlet הנתון להלן כדי להפעיל את הקוד:
צומת forkchild. js 
מהפלט הזה, מוכח שתקשורת תהליך הורה-ילד מתבצעת כראוי.
גישה 3: יצירת תהליכי Child ב-node.js באמצעות שיטת 'exec()'.
ה ' exec() השיטה תחילה יוצרת מעטפת ולאחר מכן מפעילה את ה-cmdlet. שיטה זו תשמש כדי לאחזר את סך הספריות.
תחביר
תהליך_ילד. exec ( cmdlet [ , אפשרויות ] [ , התקשר חזרה ] )בתחביר הנתון:
- ' cmdlet ” לוקח מחרוזת שמייצגת את הפקודה לביצוע עם ארגומנטים מופרדים ברווחים.
- ה ' אפשרויות ' כוללים 'cwd', 'קידוד', 'מעטפת' וכו'.
- ה ' התקשר חזרה ' הפונקציה מופעלת כאשר התהליך/פעולה מסתיים.
ערך החזרה
שיטה זו מאחזרת מופע ChildProcess.
כעת, עברו לקוד המפרט את מספר הספריות:
const { exec } = לִדרוֹשׁ ( 'תהליך_ילד' ) ;exec ( 'דיר | מצא /c /v ''' , ( error, stdout, stderr ) => {
אם ( שְׁגִיאָה ) {
לְנַחֵם. שְׁגִיאָה ( שגיאת הפעלה : $ { שְׁגִיאָה } ` ) ;
לַחֲזוֹר ;
}
לְנַחֵם. עֵץ ( `סטדאוט : מספר של מדריכים -> $ { stdout } ` ) ;
אם ( סטדרר != '' )
לְנַחֵם. שְׁגִיאָה ( `סטדרר : $ { סטדרר } ` ) ;
} ) ;
בקטע קוד זה, כלול את ' תהליך_ילד מודול ליצירה/יצירת תהליכים צאצאים. לאחר מכן, התמודד עם החריגים/שגיאות המתמודדים עם והצג את המספר הכולל של ספריות בספריית העבודה הנוכחית.
תְפוּקָה
בצע את הקוד הבא כדי להפעיל את הקוד:
מנהל צומת. js 
בפלט זה, ניתן לרמוז שסך כל הספריות בספריית העבודה הנוכחית מוצגות.
גישה 4: יצירת תהליכי Child ב-node.js באמצעות שיטת execFile()
בתוך ה ' execFile() שיטת ', קובץ ההפעלה היעד נוצר ישירות בצורה של תהליך חדש ולכן הוא יעיל יותר מה-' exec() ' שיטה. שיטה זו מולידה את ' execchild.js ' קובץ בצורה של תהליך חדש.
תחביר
תהליך_ילד. execFile ( שם קובץ [ , טוען ] [ , אפשרויות ] [ , התקשר חזרה ] )בתחביר הנתון:
- ' שם קובץ ' לוקח מחרוזת שמייצגת את שם הקובץ או הנתיב לביצוע.
- ' args ' מתאים לרשימת הארגומנטים של המחרוזת.
- ה ' אפשרויות ' כוללים 'cwd', 'קידוד', 'מעטפת' וכו'.
- ה ' התקשר חזרה ' הפונקציה מופעלת כאשר התהליך מסתיים. הארגומנטים של הפונקציה יכולים להיות error, stdout וכו'.
ערך החזרה
שיטה זו גם מאחזרת מופע ChildProcess.
כעת, שקול את הקוד הבא שמוליד את קובץ ההפעלה היעד כתהליך חדש:
const { execFile } = לִדרוֹשׁ ( 'תהליך_ילד' ) ;const איקס = execFile ( 'צוֹמֶת' , [ 'execchild.js' ] ,
( error, stdout, stderr ) => {
אם ( שְׁגִיאָה ) {
לזרוק שְׁגִיאָה ;
}
לְנַחֵם. עֵץ ( stdout ) ;
} ) ;
בהתבסס על שורות קוד אלה, החל את השלבים הבאים:
- חזור על ההליך הנדון עבור הכללת ' תהליך_ילד ' מודול.
- בשלב הבא, החל את ' execFile() שיטה המולידה את קובץ ההפעלה שצוין (שנדונה בגישה הקודמת) כתהליך חדש, ובכך מפרטת את סך הספריות בספריית העבודה.
תְפוּקָה
הפעל את ה-cmdlet שלהלן כדי להפעיל את הקוד:
node execfile. js 
בתוצאה זו, ניתן לוודא שקובץ ההפעלה שצוין נוצר ומספר הספריות מוצג.
סיכום
ניתן ליצור את תהליכי הצאצא ב-Node.js באמצעות ' לְהַשְׁרִיץ() שיטת ', ה' מזלג() שיטת ', ה' exec() שיטת ', או ה' execFile() ' שיטה. גישות אלו מולידות את תהליך הצאצא, מאפשרות תקשורת בין תהליך הורה-ילד, או רשימת ספריות בספריית העבודה הנוכחית (ישירות או באמצעות השראת קובץ ההפעלה היעד), בהתאמה.