Durante la programmazione in “ nodo.js ”, un singolo processo non è mai efficiente per far fronte al crescente carico di lavoro dell’applicazione. Pertanto, possono esserci determinate situazioni in cui lo sviluppatore deve creare nuovi processi, lavorare con attività a lungo termine e consentire l'interazione con il sistema operativo. Ciò può essere ottenuto creando processi secondari per utilizzare più processi, ridimensionando così un'applicazione Node.
Questo articolo spiega il contenuto elencato di seguito:
- Cos'è un processo figlio?
- Come creare processi secondari in Node.js?
- Creazione di processi secondari in node.js tramite il ' produrre() ' Metodo.
- Creazione di processi secondari in node.js utilizzando il comando ' forchetta() ' Metodo.
- Creazione di processi secondari in node.js utilizzando il comando ' exec() ' Metodo.
- Creazione di processi secondari in node.js utilizzando il comando ' execFile() ' Metodo.
Cos'è un processo figlio?
Un processo figlio corrisponde a un processo creato tramite un altro processo, ad esempio genitore. Node.js fornisce il ' processo_figlio ” che garantisce la comunicazione efficace tra i processi figli. Inoltre, questo modulo aiuta a richiamare le funzionalità del sistema operativo eseguendo qualsiasi comando di sistema all'interno di un processo figlio.
Come creare processi secondari in Node.js?
Il bambino elabora in “ nodo.js ' può essere creato tramite gli approcci indicati di seguito:
- “ produrre() ' Metodo.
- “ forchetta() ' Metodo.
- “ exec() ' Metodo.
- “ execFile() ' Metodo.
Approccio 1: Creazione di processi secondari in node.js tramite il metodo 'spawn()'.
IL ' produrre() ' Il metodo genera un cmdlet in un nuovo processo utilizzando il cmdlet fornito e gli argomenti della riga di comando. L'istanza ChildProcess applica/implementa l'API EventEmitter che consente di registrare gestori per eventi su oggetti figlio. Questi eventi includono uscita, disconnessione, errore, messaggio e chiusura.
Sintassi
processo_figlio. produrre ( cmdlet [ , argomenta ] [ , opzioni ] )In questa sintassi:
- cmdlet: Richiede una stringa che è il cmdlet da eseguire.
- argomenti: Si riferisce all'elenco degli argomenti di stringa. Il valore predefinito è un array null.
- IL ' opzioni ' può essere una 'shell' che assume un valore booleano. È tale che se è “ VERO ”, il cmdlet viene eseguito dall'interno della shell. Il valore predefinito è ' falso ” che implica l'assenza di shell. Per impostazione predefinita, ' produrre() ' non crea/genera una shell per eseguire il cmdlet, pertanto è fondamentale passarlo come 'opzione' durante l'accesso al processo figlio.
Valore di ritorno: Questo metodo recupera un oggetto ChildProcess.
Di seguito è riportata la dimostrazione della creazione di un processo figlio:
cost { produrre } = richiedere ( 'processo_figlio' ) ;cost bambino = produrre ( 'Voi' , [ 'D: \S ETUPS' ] , { conchiglia : VERO } ) ;
bambino. stdout . SU ( 'dati' , ( dati ) => {
consolle. tronco d'albero ( `stdout : $ { dati } ` ) ;
} ) ;
bambino. stderr . SU ( 'dati' , ( dati ) => {
consolle. errore ( 'stderr.' : $ { dati } ` ) ;
} ) ;
bambino. SU ( 'vicino' , ( codice ) => {
consolle. tronco d'albero ( `il processo figlio è terminato con il codice $ { codice } ` ) ;
} ) ;
In questo blocco di codice:
- Prima di tutto, includere il ' processo_figlio ' modulo per la creazione di un processo figlio.
- Successivamente, genera un processo figlio per visualizzare i contenuti nel percorso specificato, ad esempio ' D:\IMPOSTAZIONI ”.
- Infine, il “ vicino ” viene richiamato quando si esce dall'intero processo figlio e il messaggio di uscita viene visualizzato sulla console.
Produzione
Qui, esegui il seguente cmdlet per eseguire il codice e visualizzare il contenuto nel percorso di destinazione:
temperatura del nodo js 
Approccio 2: Creazione di processi secondari in node.js utilizzando il metodo 'fork()'.
Questo metodo è associato al “ produrre() ' Metodo in cui la comunicazione tra i processi del bambino e del genitore può essere effettuata tramite il ' Inviare() ' metodo.
IL ' forchetta() Il metodo separa le complesse attività di calcolo dal ciclo degli eventi (principale). Questo metodo può essere utilizzato per accedere a più processi secondari ma può influire sulle prestazioni complessive poiché ogni processo ha la propria memoria.
Sintassi
processo_figlio. forchetta ( mdpath [ , argomenta ] [ , opzioni ] )Secondo questa sintassi:
- “ mdpath ” prende una stringa che rappresenta il modulo da eseguire nel figlio.
- “ arg ' si riferisce a un elenco di argomenti di tipo stringa.
- “ opzioni ” può essere “execPath”, “env”, “CWD”, “ staccato” e “execArgv”.
Valore di ritorno: Questo metodo recupera un'istanza ChildProcess.
Codice (processo principale)
Ora, esamina il blocco di codice indicato di seguito che consente la comunicazione tra i processi genitore e figlio con l'aiuto del ' Inviare() ' metodo:
cost cp = richiedere ( 'processo_figlio' ) ;lascia che il bambino = cp. forchetta ( __nomedir + '/fork2.js' ) ;
bambino. SU ( 'Messaggio' , funzione ( X ) {
consolle. tronco d'albero ( 'Il processo principale ha ottenuto:' , X ) ;
} ) ;
bambino. Inviare ( { Ciao : 'dal processo principale' } ) ;
bambino. SU ( 'vicino' , ( codice ) => {
consolle. tronco d'albero ( `il processo figlio è terminato con il codice $ { codice } ` ) ;
} ) ;
In questo codice:
- Allo stesso modo, incorporare il “ processo_figlio ' modulo per la creazione di un processo figlio.
- Ora, specifica il percorso del processo figlio tramite il pulsante “ forchetta() ' metodo.
- Infine, visualizza il messaggio che rappresenta il processo principale tramite il pulsante “ Inviare() ' e visualizza gli errori riscontrati, se presenti.
Codice (processo figlio)
Il seguente file di codice, ad esempio ' fork2.js ' rappresenta il processo figlio che invia anche il messaggio utilizzando il ' Inviare() 'metodo, come segue:
processi. SU ( 'Messaggio' , funzione ( M ) {consolle. tronco d'albero ( 'Il processo figlio ha ottenuto:' , M ) ;
} ) ;
processi. Inviare ( { Ciao : 'dal processo figlio' } ) ;
Produzione
Ora esegui il cmdlet indicato di seguito per eseguire il codice:
nodo forkchild. js 
Da questo output si conferma che la comunicazione del processo genitore-figlio viene eseguita in modo appropriato.
Approccio 3: Creazione di processi secondari in node.js utilizzando il metodo 'exec()'.
IL ' exec() ' Il metodo crea prima una shell e quindi esegue il cmdlet. Questo metodo verrà utilizzato per recuperare le directory totali.
Sintassi
processo_figlio. esecutivo ( cmdlet [ , opzioni ] [ , richiamare ] )Nella sintassi data:
- “ cmdlet ” accetta una stringa che rappresenta il comando da eseguire con argomenti separati da spazi.
- IL ' opzioni ' includono 'cwd', 'codifica', 'shell' ecc.
- IL ' richiamare ” viene richiamata al termine del processo/operazione.
Valore di ritorno
Questo metodo recupera un'istanza ChildProcess.
Ora passa al codice che elenca il numero di directory:
cost { esecutivo } = richiedere ( 'processo_figlio' ) ;esecutivo ( 'dir | trova /c /v ''' , ( errore, stdout, stderr ) => {
Se ( errore ) {
consolle. errore ( 'Errore di esecuzione'. : $ { errore } ` ) ;
ritorno ;
}
consolle. tronco d'albero ( `stdout : Numero delle Directory -> $ { stdout } ` ) ;
Se ( stderr != '' )
consolle. errore ( 'stderr.' : $ { stderr } ` ) ;
} ) ;
In questo frammento di codice, includi ' processo_figlio ” modulo per creare/creare processi figli. Successivamente, gestisci le eccezioni/errori riscontrati e visualizza il numero totale di directory nella directory di lavoro corrente.
Produzione
Eseguire il codice seguente per eseguire il codice:
nodo execchild. js 
In questo output può essere implicito che vengano visualizzate tutte le directory nella directory di lavoro corrente.
Approccio 4: Creazione di processi secondari in node.js utilizzando il metodo execFile()
Nel ' execFile() ', il file eseguibile di destinazione viene generato direttamente sotto forma di un nuovo processo quindi è più efficiente del ' exec() ' metodo. Questo metodo genera il creato ' execchild.js 'file sotto forma di un nuovo processo.
Sintassi
processo_figlio. execFile ( nome del file [ , argomenta ] [ , opzioni ] [ , richiamare ] )Nella sintassi data:
- “ nome del file ' accetta una stringa che rappresenta il nome o il percorso del file da eseguire.
- “ arg ” corrisponde all'elenco degli argomenti di stringa.
- IL ' opzioni ' includono 'cwd', 'codifica', 'shell' ecc.
- IL ' richiamare La funzione viene richiamata al termine del processo. Gli argomenti della funzione possono essere error, stdout, ecc.
Valore di ritorno
Questo metodo recupera anche un'istanza ChildProcess.
Consideriamo ora il seguente codice che genera il file eseguibile di destinazione come un nuovo processo:
cost { execFile } = richiedere ( 'processo_figlio' ) ;cost X = execFile ( 'nodo' , [ 'execchild.js' ] ,
( errore, stdout, stderr ) => {
Se ( errore ) {
gettare errore ;
}
consolle. tronco d'albero ( stdout ) ;
} ) ;
Sulla base di queste righe di codice, applicare i seguenti passaggi:
- Ripetere la procedura discussa per includere il ' processo_figlio ' modulo.
- Nel passaggio successivo, applica il ' execFile() ' che genera il file eseguibile specificato (discusso nell'approccio precedente) come un nuovo processo, elencando così le directory totali nella directory di lavoro.
Produzione
Esegui il cmdlet seguente per eseguire il codice:
file eseguibile del nodo. js 
In questo risultato, è possibile verificare che il file eseguibile specificato venga generato e che venga visualizzato il numero di directory.
Conclusione
I processi secondari in Node.js possono essere creati tramite il comando ' produrre() ', il metodo ' forchetta() ', il metodo ' exec() ', o il metodo ' execFile() ' metodo. Questi approcci generano rispettivamente il processo figlio, abilitano la comunicazione del processo padre-figlio o elencano le directory nella directory di lavoro corrente (direttamente o generando il file eseguibile di destinazione).