'లో ప్రోగ్రామింగ్ చేస్తున్నప్పుడు node.js ”, అప్లికేషన్ యొక్క పెరుగుతున్న పనిభారాన్ని ఎదుర్కోవడానికి ఒకే ప్రక్రియ ఎప్పుడూ సమర్థవంతంగా ఉండదు. అందువల్ల, డెవలపర్ కొత్త ప్రక్రియలను సృష్టించడం, దీర్ఘకాలిక పనులతో పని చేయడం మరియు ఆపరేటింగ్ సిస్టమ్‌తో పరస్పర చర్యను ప్రారంభించడం వంటి కొన్ని పరిస్థితులు ఉండవచ్చు. బహుళ ప్రక్రియలను ఉపయోగించుకోవడానికి చైల్డ్ ప్రాసెస్‌లను సృష్టించడం ద్వారా దీనిని సాధించవచ్చు, తద్వారా నోడ్ అప్లికేషన్‌ను స్కేల్ చేయవచ్చు.
ఈ వ్రాత దిగువ జాబితా చేయబడిన కంటెంట్‌ను వివరిస్తుంది:
- చైల్డ్ ప్రాసెస్ అంటే ఏమిటి?
- Node.jsలో చైల్డ్ ప్రాసెస్‌లను ఎలా సృష్టించాలి?
- node.jsలో చైల్డ్ ప్రాసెస్‌లను సృష్టించడం ద్వారా ' స్పాన్() ”పద్ధతి.
- 'ని ఉపయోగించి node.jsలో చైల్డ్ ప్రాసెస్‌లను సృష్టించడం ఫోర్క్() ”పద్ధతి.
- 'ని ఉపయోగించి node.jsలో చైల్డ్ ప్రాసెస్‌లను సృష్టించడం కార్యనిర్వాహకుడు () ”పద్ధతి.
- 'ని ఉపయోగించి node.jsలో చైల్డ్ ప్రాసెస్‌లను సృష్టించడం execFile() ”పద్ధతి.
చైల్డ్ ప్రాసెస్ అంటే ఏమిటి?
పిల్లల ప్రక్రియ మరొక ప్రక్రియ ద్వారా సృష్టించబడిన ప్రక్రియకు అనుగుణంగా ఉంటుంది, అనగా పేరెంట్. Node.js అందిస్తుంది “ పిల్లల_ప్రక్రియ ” మాడ్యూల్ పిల్లల ప్రక్రియల మధ్య సమర్థవంతమైన సంభాషణను నిర్ధారిస్తుంది. అలాగే, ఈ మాడ్యూల్ చైల్డ్ ప్రాసెస్‌లో ఏదైనా సిస్టమ్ కమాండ్‌ని అమలు చేయడం ద్వారా ఆపరేటింగ్ సిస్టమ్ ఫీచర్‌లను అమలు చేయడంలో సహాయపడుతుంది.
Node.jsలో చైల్డ్ ప్రాసెస్‌లను ఎలా సృష్టించాలి?
చైల్డ్ ప్రాసెస్ చేస్తుంది ' node.js ' దిగువ పేర్కొన్న విధానాల ద్వారా సృష్టించవచ్చు:
- ' స్పాన్() ”పద్ధతి.
- ' ఫోర్క్() ”పద్ధతి.
- ' కార్యనిర్వాహకుడు () ”పద్ధతి.
- ' execFile() ”పద్ధతి.
విధానం 1: 'స్పాన్()' పద్ధతి ద్వారా node.jsలో చైల్డ్ ప్రాసెస్‌లను సృష్టించడం
ది ' స్పాన్() ” పద్ధతి అందించిన cmdlet మరియు కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను ఉపయోగించి కొత్త ప్రక్రియలో cmdletని ఉత్పత్తి చేస్తుంది. చైల్డ్ ప్రాసెస్ ఉదాహరణ ఈవెంట్‌ఎమిటర్ APIని వర్తింపజేస్తుంది/అమలు చేస్తుంది, ఇది చైల్డ్ ఆబ్జెక్ట్‌లపై ఈవెంట్‌ల కోసం హ్యాండ్లర్‌లను నమోదు చేయడానికి అనుమతిస్తుంది. ఈ ఈవెంట్‌లలో నిష్క్రమణ, డిస్‌కనెక్ట్, ఎర్రర్, మెసేజ్ మరియు క్లోజ్ ఉన్నాయి.
వాక్యనిర్మాణం
పిల్లల_ప్రక్రియ. మొలకెత్తుతుంది ( cmdlet [ , ఆర్గ్స్ ] [ , ఎంపికలు ] )ఈ వాక్యనిర్మాణంలో:
- cmdlet: ఇది అమలు చేయడానికి cmdlet అయిన స్ట్రింగ్‌ను తీసుకుంటుంది.
- వాదనలు: ఇది స్ట్రింగ్ ఆర్గ్యుమెంట్స్ జాబితాను సూచిస్తుంది. డిఫాల్ట్ విలువ శూన్య శ్రేణి.
- ది ' ఎంపికలు ” అనేది బూలియన్ విలువను తీసుకునే “షెల్” కావచ్చు. అది అలా అయితే ' నిజం ”, cmdlet షెల్ లోపల నుండి అమలు చేయబడుతుంది. డిఫాల్ట్ విలువ ' తప్పుడు ” అంటే షెల్ లేదు. డిఫాల్ట్‌గా, ' స్పాన్() ” cmdletని అమలు చేయడానికి షెల్‌ను సృష్టించదు/జెనరేట్ చేయదు కాబట్టి, చైల్డ్ ప్రాసెస్‌ను యాక్సెస్ చేస్తున్నప్పుడు దానిని “ఐచ్ఛికం”గా పాస్ చేయడం చాలా కీలకం.
రిటర్న్ విలువ: ఈ పద్ధతి చైల్డ్ ప్రాసెస్ వస్తువును తిరిగి పొందుతుంది.
చైల్డ్ ప్రాసెస్‌ని సృష్టించే ప్రదర్శన క్రిందిది:
స్థిరంగా { మొలకెత్తుతుంది } = అవసరం ( 'పిల్లల_ప్రక్రియ' ) ;స్థిరంగా బిడ్డ = మొలకెత్తుతుంది ( 'నువ్వు' , [ 'డి: \S ETUPS' ] , { షెల్ : నిజం } ) ;
బిడ్డ. stdout . పై ( 'సమాచారం' , ( సమాచారం ) => {
కన్సోల్. లాగ్ ( `stdout : $ { సమాచారం } ` ) ;
} ) ;
బిడ్డ. stderr . పై ( 'సమాచారం' , ( సమాచారం ) => {
కన్సోల్. లోపం ( `stderr : $ { సమాచారం } ` ) ;
} ) ;
బిడ్డ. పై ( 'దగ్గరగా' , ( కోడ్ ) => {
కన్సోల్. లాగ్ ( `$ కోడ్‌తో చైల్డ్ ప్రాసెస్ నిష్క్రమించబడింది { కోడ్ } ` ) ;
} ) ;
ఈ కోడ్ బ్లాక్‌లో:
- అన్నింటిలో మొదటిది, చేర్చండి ' పిల్లల_ప్రక్రియ ” చైల్డ్ ప్రాసెస్‌ని రూపొందించడానికి మాడ్యూల్.
- ఆ తర్వాత, పేర్కొన్న మార్గంలో కంటెంట్‌లను ప్రదర్శించడం కోసం చైల్డ్ ప్రాసెస్‌ను ప్రారంభించండి అంటే, ' D:\SETUPS ”.
- చివరగా, ' దగ్గరగా 'చైల్డ్ ప్రాసెస్ మొత్తం నిష్క్రమించినప్పుడు మరియు నిష్క్రమణ సందేశం కన్సోల్‌లో ప్రదర్శించబడినప్పుడు ఈవెంట్ ప్రారంభించబడుతుంది.
అవుట్‌పుట్
ఇక్కడ, కోడ్‌ను అమలు చేయడానికి మరియు లక్ష్య మార్గంలో కంటెంట్‌లను ప్రదర్శించడానికి క్రింది cmdletని అమలు చేయండి:
నోడ్ ఉష్ణోగ్రత. js 
విధానం 2: “ఫోర్క్()” పద్ధతిని ఉపయోగించి node.jsలో చైల్డ్ ప్రాసెస్‌లను సృష్టిస్తోంది
ఈ పద్ధతి ' స్పాన్() 'చైల్డ్ మరియు పేరెంట్ ప్రాసెస్‌ల మధ్య కమ్యూనికేషన్‌ను దీని ద్వారా నిర్వహించగల పద్ధతి' పంపు() ” పద్ధతి.
ది ' ఫోర్క్() ” పద్ధతి సంక్లిష్ట గణన పనులను ఈవెంట్ లూప్ (ప్రధాన) నుండి వేరు చేస్తుంది. బహుళ చైల్డ్ ప్రాసెస్‌లను యాక్సెస్ చేయడానికి ఈ పద్ధతిని ఉపయోగించవచ్చు కానీ ప్రతి ప్రక్రియకు దాని స్వంత మెమరీ ఉన్నందున ఇది మొత్తం పనితీరును ప్రభావితం చేస్తుంది.
వాక్యనిర్మాణం
పిల్లల_ప్రక్రియ. ఫోర్క్ ( mdpath [ , ఆర్గ్స్ ] [ , ఎంపికలు ] )ఈ వాక్యనిర్మాణం ప్రకారం:
- ' mdpath ” పిల్లలలో అమలు చేయడానికి మాడ్యూల్‌ను సూచించే స్ట్రింగ్‌ను తీసుకుంటుంది.
- ' ఆర్గ్స్ ” అనేది స్ట్రింగ్ ఆర్గ్యుమెంట్‌ల జాబితాను సూచిస్తుంది.
- ' ఎంపికలు ” “execPath”, “env”, “CWD”, “డిటాచ్డ్” మరియు “execArgv” కావచ్చు.
రిటర్న్ విలువ: ఈ పద్ధతి చైల్డ్ ప్రాసెస్ ఉదాహరణను తిరిగి పొందుతుంది.
కోడ్(తల్లిదండ్రుల ప్రక్రియ)
ఇప్పుడు, '' సహాయంతో తల్లిదండ్రులు మరియు పిల్లల ప్రక్రియల మధ్య కమ్యూనికేషన్‌ను ప్రారంభించే దిగువ-ఇచ్చిన కోడ్ బ్లాక్ ద్వారా వెళ్ళండి పంపు() 'పద్ధతి:
స్థిరంగా cp = అవసరం ( 'పిల్లల_ప్రక్రియ' ) ;బిడ్డను అనుమతించు = cp ఫోర్క్ ( __డిపేరు + '/fork2.js' ) ;
బిడ్డ. పై ( 'సందేశం' , ఫంక్షన్ ( x ) {
కన్సోల్. లాగ్ ( 'తల్లిదండ్రుల ప్రక్రియ వచ్చింది:' , x ) ;
} ) ;
బిడ్డ. పంపండి ( { హలో : 'తల్లిదండ్రుల ప్రక్రియ నుండి' } ) ;
బిడ్డ. పై ( 'దగ్గరగా' , ( కోడ్ ) => {
కన్సోల్. లాగ్ ( `$ కోడ్‌తో చైల్డ్ ప్రాసెస్ నిష్క్రమించబడింది { కోడ్ } ` ) ;
} ) ;
ఈ కోడ్‌లో:
- అదేవిధంగా, 'ని చేర్చండి పిల్లల_ప్రక్రియ ” చైల్డ్ ప్రాసెస్‌ని రూపొందించడానికి మాడ్యూల్.
- ఇప్పుడు, '' ద్వారా చైల్డ్ ప్రాసెస్ యొక్క మార్గాన్ని పేర్కొనండి ఫోర్క్() ” పద్ధతి.
- చివరగా, '' ద్వారా పేరెంట్ ప్రాసెస్‌ను సూచించే సందేశాన్ని ప్రదర్శించండి పంపు() ” పద్ధతి మరియు ఎదుర్కొన్న లోపం(లు) ఏదైనా ఉంటే వాటిని ప్రదర్శించండి.
కోడ్(చైల్డ్ ప్రాసెస్)
కింది కోడ్ ఫైల్ అంటే, ' fork2.js ' చైల్డ్ ప్రాసెస్‌ను సూచిస్తుంది, అది 'ని ఉపయోగించి సందేశాన్ని కూడా పంపుతుంది పంపు() 'పద్ధతి, క్రింది విధంగా:
ప్రక్రియ. పై ( 'సందేశం' , ఫంక్షన్ ( m ) {కన్సోల్. లాగ్ ( 'చైల్డ్ ప్రాసెస్ వచ్చింది:' , m ) ;
} ) ;
ప్రక్రియ. పంపండి ( { హలో : 'పిల్లల ప్రక్రియ నుండి' } ) ;
అవుట్‌పుట్
ఇప్పుడు, కోడ్‌ని అమలు చేయడానికి క్రింద ఇవ్వబడిన cmdletని అమలు చేయండి:
నోడ్ ఫోర్క్ చైల్డ్. js 
ఈ అవుట్‌పుట్ నుండి, పేరెంట్-చైల్డ్ ప్రాసెస్ కమ్యూనికేషన్ సముచితంగా నిర్వహించబడుతుందని నిర్ధారించబడింది.
విధానం 3: “exec()” పద్ధతిని ఉపయోగించి node.jsలో చైల్డ్ ప్రాసెస్‌లను సృష్టిస్తోంది
ది ' కార్యనిర్వాహకుడు () ” పద్ధతి మొదట షెల్‌ను సృష్టించి, ఆపై cmdletని అమలు చేస్తుంది. మొత్తం డైరెక్టరీలను తిరిగి పొందడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది.
వాక్యనిర్మాణం
పిల్లల_ప్రక్రియ. కార్యనిర్వాహకుడు ( cmdlet [ , ఎంపికలు ] [ , తిరిగి కాల్ చేయండి ] )ఇచ్చిన సింటాక్స్‌లో:
- ' cmdlet ” స్పేస్-వేరు చేయబడిన ఆర్గ్యుమెంట్‌లతో అమలు చేయడానికి ఆదేశాన్ని సూచించే స్ట్రింగ్‌ను తీసుకుంటుంది.
- ది ' ఎంపికలు 'cwd', 'ఎన్‌కోడింగ్', 'షెల్' మొదలైనవి ఉన్నాయి.
- ది ' తిరిగి కాల్ చేయండి ప్రక్రియ/ఆపరేషన్ ముగిసినప్పుడు ” ఫంక్షన్ ప్రారంభించబడుతుంది.
రిటర్న్ విలువ
ఈ పద్ధతి చైల్డ్ ప్రాసెస్ ఉదాహరణను తిరిగి పొందుతుంది.
ఇప్పుడు, డైరెక్టరీల సంఖ్యను జాబితా చేసే కోడ్‌కు వెళ్లండి:
స్థిరంగా { కార్యనిర్వాహకుడు } = అవసరం ( 'పిల్లల_ప్రక్రియ' ) ;కార్యనిర్వాహకుడు ( 'dir | కనుగొను /c /v ''' , ( లోపం, stdout, stderr ) => {
ఉంటే ( లోపం ) {
కన్సోల్. లోపం ( `ఎగ్జిక్యూటివ్ లోపం : $ { లోపం } ` ) ;
తిరిగి ;
}
కన్సోల్. లాగ్ ( `stdout : సంఖ్య డైరెక్టరీల -> $ { stdout } ` ) ;
ఉంటే ( stderr != '' )
కన్సోల్. లోపం ( `stderr : $ { stderr } ` ) ;
} ) ;
ఈ కోడ్ స్నిప్పెట్‌లో, ' పిల్లల_ప్రక్రియ ” చైల్డ్ ప్రాసెస్‌లను రూపొందించడానికి/తయారు చేయడానికి మాడ్యూల్. ఆ తర్వాత, ఎదుర్కొన్న మినహాయింపులు/లోపాలను ఎదుర్కోండి మరియు ప్రస్తుత వర్కింగ్ డైరెక్టరీలో మొత్తం డైరెక్టరీల సంఖ్యను ప్రదర్శించండి.
అవుట్‌పుట్
కోడ్‌ని అమలు చేయడానికి క్రింది కోడ్‌ను అమలు చేయండి:
నోడ్ ఎక్సిచైల్డ్. js 
ఈ అవుట్‌పుట్‌లో, ప్రస్తుత వర్కింగ్ డైరెక్టరీలోని మొత్తం డైరెక్టరీలు ప్రదర్శించబడతాయని సూచించవచ్చు.
విధానం 4: execFile() పద్ధతిని ఉపయోగించి node.jsలో చైల్డ్ ప్రాసెస్‌లను సృష్టిస్తోంది
లో ' execFile() 'పద్ధతి, లక్ష్యం ఎక్జిక్యూటబుల్ ఫైల్ నేరుగా కొత్త ప్రక్రియ రూపంలో సృష్టించబడుతుంది కాబట్టి ఇది ' కంటే మరింత సమర్థవంతంగా ఉంటుంది కార్యనిర్వాహకుడు () ” పద్ధతి. ఈ పద్ధతి సృష్టించిన ' execchild.js ” ఫైల్ కొత్త ప్రక్రియ రూపంలో ఉంటుంది.
వాక్యనిర్మాణం
పిల్లల_ప్రక్రియ. execFile ( ఫైల్ పేరు [ , ఆర్గ్స్ ] [ , ఎంపికలు ] [ , తిరిగి కాల్ చేయండి ] )ఇచ్చిన సింటాక్స్‌లో:
- ' ఫైల్ పేరు ” ఫైల్ పేరు లేదా అమలు చేయడానికి మార్గాన్ని సూచించే స్ట్రింగ్‌ను తీసుకుంటుంది.
- ' ఆర్గ్స్ ” స్ట్రింగ్ ఆర్గ్యుమెంట్స్ జాబితాకు అనుగుణంగా ఉంటుంది.
- ది ' ఎంపికలు 'cwd', 'ఎన్‌కోడింగ్', 'షెల్' మొదలైనవి ఉన్నాయి.
- ది ' తిరిగి కాల్ చేయండి ప్రక్రియ ముగిసినప్పుడు ” ఫంక్షన్ ప్రారంభించబడుతుంది. ఫంక్షన్ వాదనలు లోపం, stdout మొదలైనవి కావచ్చు.
రిటర్న్ విలువ
ఈ పద్ధతి చైల్డ్ ప్రాసెస్ ఉదాహరణను కూడా తిరిగి పొందుతుంది.
ఇప్పుడు, టార్గెట్ ఎక్జిక్యూటబుల్ ఫైల్‌ను కొత్త ప్రక్రియగా రూపొందించే క్రింది కోడ్‌ను పరిగణించండి:
స్థిరంగా { execFile } = అవసరం ( 'పిల్లల_ప్రక్రియ' ) ;స్థిరంగా x = execFile ( 'నోడ్' , [ 'execchild.js' ] ,
( లోపం, stdout, stderr ) => {
ఉంటే ( లోపం ) {
త్రో లోపం ;
}
కన్సోల్. లాగ్ ( stdout ) ;
} ) ;
ఈ కోడ్ లైన్ల ఆధారంగా, క్రింది దశలను వర్తింపజేయండి:
- 'ని చేర్చడానికి చర్చించిన విధానాన్ని పునరావృతం చేయండి పిల్లల_ప్రక్రియ ” మాడ్యూల్.
- తదుపరి దశలో, “ని వర్తింపజేయండి execFile() ”పద్ధతి అనేది పేర్కొన్న ఎక్జిక్యూటబుల్ ఫైల్‌ను (మునుపటి విధానంలో చర్చించబడింది) ఒక కొత్త ప్రక్రియగా రూపొందిస్తుంది, తద్వారా వర్కింగ్ డైరెక్టరీలో మొత్తం డైరెక్టరీలను జాబితా చేస్తుంది.
అవుట్‌పుట్
కోడ్‌ను అమలు చేయడానికి క్రింది cmdletని అమలు చేయండి:
నోడ్ ఎక్సెక్ఫైల్. js 
ఈ ఫలితంలో, పేర్కొన్న ఎక్జిక్యూటబుల్ ఫైల్ స్పాన్ చేయబడిందని మరియు డైరెక్టరీల సంఖ్య ప్రదర్శించబడిందని ధృవీకరించవచ్చు.
ముగింపు
Node.jsలోని చైల్డ్ ప్రాసెస్‌లను దీని ద్వారా సృష్టించవచ్చు స్పాన్() 'పద్ధతి,' ఫోర్క్() 'పద్ధతి,' కార్యనిర్వాహకుడు () 'పద్ధతి, లేదా' execFile() ” పద్ధతి. ఈ విధానాలు చైల్డ్ ప్రాసెస్‌కు దారితీస్తాయి, పేరెంట్-చైల్డ్ ప్రాసెస్ కమ్యూనికేషన్‌ను ఎనేబుల్ చేస్తాయి లేదా ప్రస్తుత వర్కింగ్ డైరెక్టరీలో డైరెక్టరీలను జాబితా చేస్తాయి (నేరుగా లేదా టార్గెట్ ఎక్జిక్యూటబుల్ ఫైల్‌ను స్పాన్ చేయడం ద్వారా).