Mientras programa en “ nodo.js ”, un solo proceso nunca es eficiente para hacer frente a la creciente carga de trabajo de la aplicación. Por lo tanto, puede haber determinadas situaciones en las que el desarrollador necesite crear nuevos procesos, trabajar con tareas a largo plazo y permitir la interacción con el sistema operativo. Esto se puede lograr creando procesos secundarios para hacer uso de múltiples procesos, escalando así una aplicación Node.
Este artículo explica el contenido que se enumera a continuación:
- ¿Qué es un proceso hijo?
- ¿Cómo crear procesos secundarios en Node.js?
- Creación de procesos secundarios en node.js a través de ' Aparecer() ' Método.
- Creando procesos secundarios en node.js usando el ' tenedor() ' Método.
- Creando procesos secundarios en node.js usando el ' ejecutivo() ' Método.
- Creando procesos secundarios en node.js usando el ' archivo ejecutivo() ' Método.
¿Qué es un proceso hijo?
Un proceso hijo corresponde a un proceso creado a través de otro proceso, es decir, padre. Node.js proporciona el ' proceso_niño ”Módulo que garantiza la comunicación efectiva entre los procesos secundarios. Además, este módulo ayuda a invocar las funciones del sistema operativo ejecutando cualquier comando del sistema dentro de un proceso secundario.
¿Cómo crear procesos secundarios en Node.js?
El niño procesa en “ nodo.js ”se puede crear a través de los enfoques que se indican a continuación:
- “ Aparecer() ' Método.
- “ tenedor() ' Método.
- “ ejecutivo() ' Método.
- “ archivo ejecutivo() ' Método.
Enfoque 1: Creación de procesos secundarios en node.js mediante el método “spawn()”
El ' Aparecer() El método genera un cmdlet en un nuevo proceso utilizando el cmdlet proporcionado y los argumentos de la línea de comando. La instancia de ChildProcess aplica/implementa la API EventEmitter que permite registrar controladores para eventos en objetos secundarios. Estos eventos incluyen salida, desconexión, error, mensaje y cierre.
Sintaxis
proceso_niño. Aparecer ( cmdlet [ , argumentos ] [ , opciones ] )En esta sintaxis:
- cmdlet: Se necesita una cadena que es el cmdlet a ejecutar.
- argumentos: Se refiere a la lista de argumentos de cadena. El valor predeterminado es una matriz nula.
- El ' opciones ” puede ser un “shell” que toma un valor booleano. Es tal que si es “ verdadero ”, el cmdlet se ejecuta desde el shell. El valor predeterminado es ' FALSO ”lo que implica que no hay caparazón. Por defecto, ' Aparecer() ” no crea/genera un shell para ejecutar el cmdlet, por lo tanto, es crucial pasarlo como una “opción” al acceder al proceso secundario.
Valor de retorno: Este método recupera un objeto ChildProcess.
A continuación se muestra la demostración de la creación de un proceso hijo:
constante { Aparecer } = requerir ( 'proceso_niño' ) ;constante niño = Aparecer ( 'tú' , [ 'D: \S ETUPS' ] , { caparazón : verdadero } ) ;
niño. salida estándar . en ( 'datos' , ( datos ) => {
consola. registro ( `salida estándar : $ { datos } ` ) ;
} ) ;
niño. stderr . en ( 'datos' , ( datos ) => {
consola. error ( `stderr : $ { datos } ` ) ;
} ) ;
niño. en ( 'cerca' , ( código ) => {
consola. registro ( `proceso hijo salió con el código $ { código } ` ) ;
} ) ;
En este bloque de código:
- En primer lugar, incluya el “ proceso_niño 'Módulo para crear un proceso hijo.
- Después de eso, genere un proceso hijo para mostrar el contenido en la ruta especificada, es decir, ' D:\CONFIGURACIONES ”.
- Por último, el “ cerca El evento 'se invoca cuando se sale de todo el proceso secundario y el mensaje de salida se muestra en la consola.
Producción
Aquí, ejecute el siguiente cmdlet para ejecutar el código y mostrar el contenido en la ruta de destino:
temperatura del nodo js 
Enfoque 2: Creación de procesos secundarios en node.js utilizando el método “fork()”
Este método está asociado con el “ Aparecer() 'Método donde la comunicación entre los procesos hijo y padre se puede llevar a cabo a través del' enviar() ' método.
El ' tenedor() El método separa las tareas de cálculo complejas del bucle de eventos (principal). Este método se puede utilizar para acceder a varios procesos secundarios, pero puede afectar el rendimiento general ya que cada proceso tiene su propia memoria.
Sintaxis
proceso_niño. tenedor ( ruta md [ , argumentos ] [ , opciones ] )Según esta sintaxis:
- “ ruta md ”toma una cadena que representa el módulo a ejecutar en el niño.
- “ argumentos ”se refiere a una lista de argumentos de cadena.
- “ opciones ' puede ser 'execPath', 'env', 'CWD', 'separado' y 'execArgv'.
Valor de retorno: Este método recupera una instancia de ChildProcess.
Código (proceso principal)
Ahora, revise el bloque de código que se proporciona a continuación que permite la comunicación entre los procesos padre e hijo con la ayuda de ' enviar() ' método:
constante CP = requerir ( 'proceso_niño' ) ;dejar niño = cp. tenedor ( __dirname + '/fork2.js' ) ;
niño. en ( 'mensaje' , función ( X ) {
consola. registro ( 'El proceso principal obtuvo:' , X ) ;
} ) ;
niño. enviar ( { Hola : 'del proceso padre' } ) ;
niño. en ( 'cerca' , ( código ) => {
consola. registro ( `proceso hijo salió con el código $ { código } ` ) ;
} ) ;
En este código:
- Asimismo, incorporar el “ proceso_niño 'Módulo para crear un proceso hijo.
- Ahora, especifique la ruta del proceso hijo a través del botón ' tenedor() ' método.
- Por último, muestre el mensaje que representa el proceso principal a través del botón ' enviar() ”Método y muestra los errores encontrados, si los hay.
Código (proceso hijo)
El siguiente archivo de código, es decir, “ fork2.js 'Representa el proceso hijo que también envía el mensaje utilizando el' enviar() 'Método, de la siguiente manera:
proceso. en ( 'mensaje' , función ( metro ) {consola. registro ( 'El proceso hijo obtuvo:' , metro ) ;
} ) ;
proceso. enviar ( { Hola : 'del proceso hijo' } ) ;
Producción
Ahora, ejecute el cmdlet que se proporciona a continuación para ejecutar el código:
nodo bifurcación. js 
A partir de este resultado, se confirma que la comunicación del proceso padre-hijo se lleva a cabo de manera adecuada.
Enfoque 3: Creación de procesos secundarios en node.js utilizando el método “exec()”
El ' ejecutivo() El método primero crea un shell y luego ejecuta el cmdlet. Este método se utilizará para recuperar el total de directorios.
Sintaxis
proceso_niño. ejecutivo ( cmdlet [ , opciones ] [ , llamar de vuelta ] )En la sintaxis dada:
- “ cmdlet ”toma una cadena que representa el comando a ejecutar con argumentos separados por espacios.
- El ' opciones ”incluyen “cwd”, “codificación”, “shell”, etc.
- El ' llamar de vuelta La función ”se invoca cuando finaliza el proceso/operación.
Valor de retorno
Este método recupera una instancia de ChildProcess.
Ahora, pase al código que enumera la cantidad de directorios:
constante { ejecutivo } = requerir ( 'proceso_niño' ) ;ejecutivo ( 'directorio | buscar /c /v ''' , ( error, salida estándar, stderr ) => {
si ( error ) {
consola. error ( `error ejecutivo : $ { error } ` ) ;
devolver ;
}
consola. registro ( `salida estándar : Número de directorios -> $ { salida estándar } ` ) ;
si ( stderr != '' )
consola. error ( `stderr : $ { stderr } ` ) ;
} ) ;
En este fragmento de código, incluya ' proceso_niño ”Módulo para crear/realizar procesos secundarios. Después de eso, solucione las excepciones/errores encontrados y muestre el número total de directorios en el directorio de trabajo actual.
Producción
Ejecute el siguiente código para ejecutar el código:
hijo ejecutivo del nodo. js 
En este resultado, se puede implicar que se muestran el total de directorios en el directorio de trabajo actual.
Enfoque 4: Creación de procesos secundarios en node.js utilizando el método execFile()
En el ' archivo ejecutivo() ', el archivo ejecutable de destino se genera directamente en forma de un nuevo proceso, por lo que es más eficiente que el' ejecutivo() ' método. Este método genera el creado ' execchild.js ”archivar en forma de un nuevo proceso.
Sintaxis
proceso_niño. archivo ejecutivo ( Nombre del archivo [ , argumentos ] [ , opciones ] [ , llamar de vuelta ] )En la sintaxis dada:
- “ Nombre del archivo ”toma una cadena que representa el nombre o la ruta del archivo a ejecutar.
- “ argumentos ”corresponde a la lista de argumentos de cadena.
- El ' opciones ”incluyen “cwd”, “codificación”, “shell”, etc.
- El ' llamar de vuelta La función ”se invoca cuando finaliza el proceso. Los argumentos de la función pueden ser error, salida estándar, etc.
Valor de retorno
Este método también recupera una instancia de ChildProcess.
Ahora, considere el siguiente código que genera el archivo ejecutable de destino como un nuevo proceso:
constante { archivo ejecutivo } = requerir ( 'proceso_niño' ) ;constante X = archivo ejecutivo ( 'nodo' , [ 'execchild.js' ] ,
( error, salida estándar, stderr ) => {
si ( error ) {
tirar error ;
}
consola. registro ( salida estándar ) ;
} ) ;
Según estas líneas de código, aplique los siguientes pasos:
- Repita el procedimiento comentado para incluir el “ proceso_niño ”módulo.
- En el siguiente paso, aplique el ' archivo ejecutivo() 'Método que genera el archivo ejecutable especificado (discutido en el enfoque anterior) como un nuevo proceso, enumerando así el total de directorios en el directorio de trabajo.
Producción
Ejecute el siguiente cmdlet para ejecutar el código:
archivo ejecutable del nodo. js 
En este resultado, se puede verificar que se genera el archivo ejecutable especificado y se muestra la cantidad de directorios.
Conclusión
Los procesos secundarios en Node.js se pueden crear mediante el botón ' Aparecer() 'Método, el' tenedor() 'Método, el' ejecutivo() ' método, o el ' archivo ejecutivo() ' método. Estos enfoques generan el proceso hijo, habilitan la comunicación del proceso padre-hijo o enumeran los directorios en el directorio de trabajo actual (directamente o generando el archivo ejecutable de destino), respectivamente.