நிரலாக்கத்தின் போது ' node.js ”, பயன்பாட்டின் அதிகரித்து வரும் பணிச்சுமையை சமாளிப்பதற்கு ஒரே ஒரு செயல்முறை ஒருபோதும் திறமையாக இருக்காது. எனவே, டெவலப்பர் புதிய செயல்முறைகளை உருவாக்க வேண்டும், நீண்ட கால பணிகளுடன் பணிபுரிய வேண்டும் மற்றும் இயக்க முறைமையுடன் தொடர்பு கொள்ள வேண்டிய சில சூழ்நிலைகள் இருக்கலாம். பல செயல்முறைகளைப் பயன்படுத்த குழந்தை செயல்முறைகளை உருவாக்குவதன் மூலம் இதை அடையலாம், இதன் மூலம் ஒரு நோட் பயன்பாட்டை அளவிடலாம்.
இந்த பதிவு கீழே பட்டியலிடப்பட்டுள்ள உள்ளடக்கத்தை விளக்குகிறது:
- குழந்தை செயல்முறை என்றால் என்ன?
- Node.js இல் குழந்தை செயல்முறைகளை உருவாக்குவது எப்படி?
- node.js இல் குழந்தை செயல்முறைகளை உருவாக்குதல் ஸ்பான்() ”முறை.
- 'ஐப் பயன்படுத்தி node.js இல் குழந்தை செயல்முறைகளை உருவாக்குதல் முள் கரண்டி() ”முறை.
- 'ஐப் பயன்படுத்தி node.js இல் குழந்தை செயல்முறைகளை உருவாக்குதல் exec() ”முறை.
- 'ஐப் பயன்படுத்தி node.js இல் குழந்தை செயல்முறைகளை உருவாக்குதல் execFile() ”முறை.
குழந்தை செயல்முறை என்றால் என்ன?
ஒரு குழந்தை செயல்முறை மற்றொரு செயல்முறை மூலம் உருவாக்கப்பட்ட செயல்முறைக்கு ஒத்திருக்கிறது, அதாவது பெற்றோர். Node.js வழங்குகிறது ' குழந்தை_செயல்முறை குழந்தை செயல்முறைகளுக்கு இடையே பயனுள்ள தொடர்பை உறுதி செய்யும் தொகுதி. மேலும், இந்த தொகுதியானது ஒரு குழந்தை செயல்முறைக்குள் ஏதேனும் கணினி கட்டளையை இயக்குவதன் மூலம் இயக்க முறைமை அம்சங்களை செயல்படுத்த உதவுகிறது.
Node.js இல் குழந்தை செயல்முறைகளை உருவாக்குவது எப்படி?
குழந்தை 'செயல்படுத்துகிறது' node.js 'கீழே கூறப்பட்ட அணுகுமுறைகள் மூலம் உருவாக்கலாம்:
- ' ஸ்பான்() ”முறை.
- ' முள் கரண்டி() ”முறை.
- ' exec() ”முறை.
- ' execFile() ”முறை.
அணுகுமுறை 1: 'spawn()' முறை மூலம் node.js இல் குழந்தை செயல்முறைகளை உருவாக்குதல்
' ஸ்பான்() ”முறையானது, வழங்கப்பட்ட cmdlet மற்றும் கட்டளை வரி வாதங்களைப் பயன்படுத்தி புதிய செயல்பாட்டில் cmdlet ஐ உருவாக்குகிறது. சைல்ட் பிராசஸ் நிகழ்வு, EventEmitter APIஐப் பயன்படுத்துகிறது/செயல்படுத்துகிறது, இது குழந்தைப் பொருள்களில் நிகழ்வுகளுக்கான ஹேண்ட்லர்களைப் பதிவுசெய்ய அனுமதிக்கிறது. இந்த நிகழ்வுகளில் வெளியேறுதல், துண்டித்தல், பிழை, செய்தி மற்றும் மூடல் ஆகியவை அடங்கும்.
தொடரியல்
குழந்தை_செயல்முறை. முட்டையிடும் ( cmdlet [ , args ] [ , விருப்பங்கள் ] )இந்த தொடரியல்:
- cmdlet: செயல்படுத்துவதற்கு cmdlet என்ற சரம் தேவைப்படுகிறது.
- args: இது சரம் வாதங்களின் பட்டியலைக் குறிக்கிறது. இயல்புநிலை மதிப்பு பூஜ்ய வரிசை.
- ' விருப்பங்கள் ” என்பது பூலியன் மதிப்பை எடுக்கும் “ஷெல்” ஆக இருக்கலாம். அது அப்படி என்றால் ' உண்மை ”, cmdlet ஷெல்லுக்குள் இருந்து செயல்படுத்தப்படுகிறது. இயல்புநிலை மதிப்பு ' பொய் ” இது ஷெல் இல்லை என்பதைக் குறிக்கிறது. இயல்பாக, ' ஸ்பான்() ” cmdlet ஐ இயக்க ஷெல்லை உருவாக்காது/உருவாக்காது எனவே, குழந்தை செயல்முறையை அணுகும் போது அதை ஒரு “விருப்பமாக” அனுப்புவது முக்கியம்.
வருவாய் மதிப்பு: இந்த முறை ஒரு ChildProcess பொருளை மீட்டெடுக்கிறது.
ஒரு குழந்தை செயல்முறையை உருவாக்குவதற்கான ஆர்ப்பாட்டம் பின்வருமாறு:
நிலையான { முட்டையிடும் } = தேவை ( 'குழந்தை_செயல்முறை' ) ;நிலையான குழந்தை = முட்டையிடும் ( 'நீ' , [ 'டி: \S ETUPS' ] , { ஷெல் : உண்மை } ) ;
குழந்தை. stdout . அன்று ( 'தகவல்கள்' , ( தகவல்கள் ) => {
பணியகம். பதிவு ( `stdout : $ { தகவல்கள் } ` ) ;
} ) ;
குழந்தை. stderr . அன்று ( 'தகவல்கள்' , ( தகவல்கள் ) => {
பணியகம். பிழை ( `stderr : $ { தகவல்கள் } ` ) ;
} ) ;
குழந்தை. அன்று ( 'நெருக்கமான' , ( குறியீடு ) => {
பணியகம். பதிவு ( $ குறியீட்டுடன் குழந்தை செயல்முறை வெளியேறியது { குறியீடு } ` ) ;
} ) ;
இந்த குறியீட்டின் தொகுதியில்:
- முதலில், ' குழந்தை_செயல்முறை 'குழந்தை செயல்முறையை உருவாக்குவதற்கான தொகுதி.
- அதன் பிறகு, குறிப்பிட்ட பாதையில் உள்ளடக்கங்களைக் காண்பிப்பதற்கான ஒரு குழந்தை செயல்முறையை உருவாக்கவும், அதாவது, ' D:\SETUPS ”.
- இறுதியாக, ' நெருக்கமான ” முழு குழந்தை செயல்முறையும் வெளியேறி, வெளியேறும் செய்தி கன்சோலில் காட்டப்படும் போது நிகழ்வு செயல்படுத்தப்படுகிறது.
வெளியீடு
இங்கே, குறியீட்டை இயக்க பின்வரும் cmdlet ஐ இயக்கவும் மற்றும் இலக்கு பாதையில் உள்ளடக்கங்களைக் காண்பிக்கவும்:
முனை வெப்பநிலை. js 
அணுகுமுறை 2: 'fork()' முறையைப் பயன்படுத்தி node.js இல் குழந்தை செயல்முறைகளை உருவாக்குதல்
இந்த முறை ' ஸ்பான்() 'குழந்தை மற்றும் பெற்றோர் செயல்முறைகளுக்கு இடையேயான தகவல்தொடர்புகள் மூலம் மேற்கொள்ளப்படும் முறை' அனுப்பு() ”முறை.
' முள் கரண்டி() ” முறை சிக்கலான கணக்கீட்டு பணிகளை நிகழ்வு வளையத்திலிருந்து (முக்கியம்) பிரிக்கிறது. பல குழந்தை செயல்முறைகளை அணுக இந்த முறை பயன்படுத்தப்படலாம் ஆனால் ஒவ்வொரு செயல்முறைக்கும் அதன் சொந்த நினைவகம் இருப்பதால் ஒட்டுமொத்த செயல்திறனை பாதிக்கலாம்.
தொடரியல்
குழந்தை_செயல்முறை. முள் கரண்டி ( mdpath [ , args ] [ , விருப்பங்கள் ] )இந்த தொடரியல் படி:
- ' mdpath ” என்பது குழந்தையில் செயல்படுத்துவதற்கான தொகுதியைக் குறிக்கும் ஒரு சரத்தை எடுக்கும்.
- ' args ” என்பது சரம் வாதங்களின் பட்டியலைக் குறிக்கிறது.
- ' விருப்பங்கள் ” “execPath”, “env”, “CWD”, “detached” மற்றும் “execArgv” ஆக இருக்கலாம்.
வருவாய் மதிப்பு: இந்த முறை ஒரு ChildProcess நிகழ்வை மீட்டெடுக்கிறது.
குறியீடு(பெற்றோர் செயல்முறை)
இப்போது, கீழே கொடுக்கப்பட்டுள்ள குறியீட்டின் மூலம் செல்லவும், இது பெற்றோருக்கும் குழந்தைக்கும் இடையேயான தகவல்தொடர்பு செயல்முறைகளின் உதவியுடன் ' அனுப்பு() ”முறை:
நிலையான cp = தேவை ( 'குழந்தை_செயல்முறை' ) ;குழந்தையை விடுங்கள் = cp. முள் கரண்டி ( __பெயர் + '/fork2.js' ) ;
குழந்தை. அன்று ( 'செய்தி' , செயல்பாடு ( எக்ஸ் ) {
பணியகம். பதிவு ( 'பெற்றோர் செயல்முறை கிடைத்தது:' , எக்ஸ் ) ;
} ) ;
குழந்தை. அனுப்பு ( { வணக்கம் : 'பெற்றோர் செயல்முறையிலிருந்து' } ) ;
குழந்தை. அன்று ( 'நெருக்கமான' , ( குறியீடு ) => {
பணியகம். பதிவு ( $ குறியீட்டுடன் குழந்தை செயல்முறை வெளியேறியது { குறியீடு } ` ) ;
} ) ;
இந்த குறியீட்டில்:
- அதேபோல், ' குழந்தை_செயல்முறை 'குழந்தை செயல்முறையை உருவாக்குவதற்கான தொகுதி.
- இப்போது, குழந்தை செயல்முறையின் பாதையைக் குறிப்பிடவும் ' முள் கரண்டி() ”முறை.
- கடைசியாக, '' வழியாக பெற்றோர் செயல்முறையைக் குறிக்கும் செய்தியைக் காண்பி அனுப்பு() ” முறை மற்றும் எதிர்கொண்ட பிழை(களை) ஏதேனும் இருந்தால் காட்டவும்.
குறியீடு(குழந்தை செயல்முறை)
பின்வரும் குறியீடு கோப்பு அதாவது, ' fork2.js ” என்பது குழந்தை செயல்முறையை பிரதிபலிக்கிறது, இது “” ஐப் பயன்படுத்தி செய்தியை அனுப்புகிறது. அனுப்பு() 'முறை, பின்வருமாறு:
செயல்முறை. அன்று ( 'செய்தி' , செயல்பாடு ( மீ ) {பணியகம். பதிவு ( 'குழந்தை செயல்முறை கிடைத்தது:' , எம் ) ;
} ) ;
செயல்முறை. அனுப்பு ( { வணக்கம் : 'குழந்தை செயல்முறையிலிருந்து' } ) ;
வெளியீடு
இப்போது, குறியீட்டை இயக்க கீழே கொடுக்கப்பட்டுள்ள cmdlet ஐ இயக்கவும்:
முனை forkchild. js 
இந்த வெளியீட்டில் இருந்து, பெற்றோர்-குழந்தை செயல்முறை தொடர்பு சரியான முறையில் மேற்கொள்ளப்படுகிறது என்பது உறுதிப்படுத்தப்பட்டுள்ளது.
அணுகுமுறை 3: 'exec()' முறையைப் பயன்படுத்தி node.js இல் குழந்தை செயல்முறைகளை உருவாக்குதல்
' exec() ” முறை முதலில் ஒரு ஷெல்லை உருவாக்கி பின்னர் cmdlet ஐ இயக்குகிறது. மொத்த அடைவுகளை மீட்டெடுக்க இந்த முறை பயன்படுத்தப்படும்.
தொடரியல்
குழந்தை_செயல்முறை. exec ( cmdlet [ , விருப்பங்கள் ] [ , திரும்ப அழைக்கவும் ] )கொடுக்கப்பட்ட தொடரியல்:
- ' cmdlet ” ஸ்பேஸ்-பிரிக்கப்பட்ட வாதங்களுடன் இயக்குவதற்கான கட்டளையைக் குறிக்கும் ஒரு சரத்தை எடுக்கிறது.
- ' விருப்பங்கள் 'cwd', 'குறியீடு', 'ஷெல்' போன்றவை அடங்கும்.
- ' திரும்ப அழைக்க செயல்முறை/செயல்பாடு முடிவடையும் போது செயல்பாடு செயல்படுத்தப்படுகிறது.
வருவாய் மதிப்பு
இந்த முறை ஒரு ChildProcess நிகழ்வை மீட்டெடுக்கிறது.
இப்போது, கோப்பகங்களின் எண்ணிக்கையைப் பட்டியலிடும் குறியீட்டிற்குச் செல்லவும்:
நிலையான { exec } = தேவை ( 'குழந்தை_செயல்முறை' ) ;exec ( 'dir | கண்டுபிடி /c /v ''' , ( பிழை, stdout, stderr ) => {
என்றால் ( பிழை ) {
பணியகம். பிழை ( `exec பிழை : $ { பிழை } ` ) ;
திரும்ப ;
}
பணியகம். பதிவு ( `stdout : எண் கோப்பகங்களின் -> $ { stdout } ` ) ;
என்றால் ( stderr != '' )
பணியகம். பிழை ( `stderr : $ { stderr } ` ) ;
} ) ;
குறியீட்டின் இந்த துணுக்கில், ' குழந்தை_செயல்முறை குழந்தை செயல்முறைகளை உருவாக்க/உருவாக்குவதற்கான தொகுதி. அதன் பிறகு, எதிர்கொள்ளும் விதிவிலக்குகள்/பிழைகளைச் சமாளித்து, தற்போதைய வேலை கோப்பகத்தில் மொத்த கோப்பகங்களின் எண்ணிக்கையைக் காண்பிக்கவும்.
வெளியீடு
குறியீட்டை இயக்க பின்வரும் குறியீட்டை இயக்கவும்:
முனை execchild. js 
இந்த வெளியீட்டில், தற்போதைய வேலை கோப்பகத்தில் உள்ள மொத்த கோப்பகங்கள் காட்டப்படும் என்பதைக் குறிக்கலாம்.
அணுகுமுறை 4: execFile() முறையைப் பயன்படுத்தி node.js இல் குழந்தை செயல்முறைகளை உருவாக்குதல்
இல் ' execFile() 'முறை, இலக்கு இயங்கக்கூடிய கோப்பு ஒரு புதிய செயல்முறையின் வடிவத்தில் நேரடியாக உருவாக்கப்படுகிறது, எனவே இது 'ஐ விட மிகவும் திறமையானது exec() ”முறை. இந்த முறை உருவாக்கப்படும் ' execchild.js ” கோப்பு ஒரு புதிய செயல்முறை வடிவத்தில்.
தொடரியல்
குழந்தை_செயல்முறை. execFile ( கோப்பு பெயர் [ , args ] [ , விருப்பங்கள் ] [ , திரும்ப அழைக்கவும் ] )கொடுக்கப்பட்ட தொடரியல்:
- ' கோப்பு பெயர் ” கோப்பின் பெயர் அல்லது இயக்க பாதையை குறிக்கும் சரத்தை எடுக்கும்.
- ' args ” என்பது சர வாதங்களின் பட்டியலுக்கு ஒத்திருக்கிறது.
- ' விருப்பங்கள் 'cwd', 'குறியீடு', 'ஷெல்' போன்றவை அடங்கும்.
- ' திரும்ப அழைக்க செயல்முறை முடிவடையும் போது செயல்பாடு செயல்படுத்தப்படுகிறது. செயல்பாட்டு வாதங்கள் பிழை, stdout போன்றவையாக இருக்கலாம்.
வருவாய் மதிப்பு
இந்த முறை ஒரு ChildProcess நிகழ்வையும் மீட்டெடுக்கிறது.
இப்போது, இலக்கு இயங்கக்கூடிய கோப்பை புதிய செயல்முறையாக உருவாக்கும் பின்வரும் குறியீட்டைக் கவனியுங்கள்:
நிலையான { execFile } = தேவை ( 'குழந்தை_செயல்முறை' ) ;நிலையான எக்ஸ் = execFile ( 'முனை' , [ 'execchild.js' ] ,
( பிழை, stdout, stderr ) => {
என்றால் ( பிழை ) {
வீசு பிழை ;
}
பணியகம். பதிவு ( stdout ) ;
} ) ;
இந்த குறியீடு வரிகளின் அடிப்படையில், பின்வரும் படிகளைப் பயன்படுத்தவும்:
- ''ஐச் சேர்ப்பதற்கான விவாதிக்கப்பட்ட நடைமுறையை மீண்டும் செய்யவும் குழந்தை_செயல்முறை ” தொகுதி.
- அடுத்த கட்டத்தில், ' execFile() ” முறையானது குறிப்பிட்ட இயங்கக்கூடிய கோப்பை (முந்தைய அணுகுமுறையில் விவாதிக்கப்பட்டது) ஒரு புதிய செயல்முறையாக உருவாக்குகிறது, இதன் மூலம் வேலை செய்யும் கோப்பகத்தில் மொத்த கோப்பகங்களை பட்டியலிடுகிறது.
வெளியீடு
குறியீட்டை இயக்க கீழே உள்ள cmdlet ஐ இயக்கவும்:
முனை execfile. js 
இந்த முடிவில், குறிப்பிட்ட இயங்கக்கூடிய கோப்பு உருவாக்கப்பட்டதா மற்றும் கோப்பகங்களின் எண்ணிக்கை காட்டப்பட்டதா என்பதை சரிபார்க்கலாம்.
முடிவுரை
Node.js இல் உள்ள குழந்தை செயல்முறைகளை '' மூலம் உருவாக்கலாம் ஸ்பான்() 'முறை,' முள் கரண்டி() 'முறை,' exec() 'முறை, அல்லது' execFile() ”முறை. இந்த அணுகுமுறைகள் குழந்தை செயல்முறைக்கு வித்திடுகின்றன, பெற்றோர்-குழந்தை செயல்முறை தொடர்பை செயல்படுத்துகின்றன அல்லது தற்போதைய வேலை கோப்பகத்தில் (நேரடியாக அல்லது இலக்கு இயங்கக்கூடிய கோப்பை உருவாக்குவதன் மூலம்) கோப்பகங்களை பட்டியலிடுகின்றன.