Como los archivos de auto-recargar en Node.js?

Question

¿Alguna idea sobre cómo podría implementar un auto-recarga de archivos en Node.js? Estoy cansado de reiniciar el servidor cada vez que cambio de un archivo. Al parecer, la función require() Node.js' no vuelve a cargar los archivos si ya han sido requeridos, por lo que tengo que hacer algo como esto:

var sys     = require('sys'), 
    http    = require('http'),
    posix   = require('posix'),
    json    = require('./json');

var script_name = '/some/path/to/app.js';
this.app = require('./app').app;

process.watchFile(script_name, function(curr, prev){
    posix.cat(script_name).addCallback(function(content){
        process.compile( content, script_name );
    });
});

http.createServer(this.app).listen( 8080 );

Y en el archivo app.js que tengo:

var file = require('./file');
this.app = function(req, res) { 
    file.serveFile( req, res, 'file.js');  
}

Pero esto también no está funcionando - Me aparece un error en la declaración process.compile() diciendo que 'requiere' no está definido. process.compile se evaling el app.js , pero no tiene ni idea acerca de las variables globales Node.js.

Answer 1

Una buena, hasta la fecha alternativa a supervisor es nodemon

  

Monitor de cualquier cambio en su aplicación Node.js y se reinicia automáticamente el servidor - perfecto para el desarrollo

Para uso nodemon:

$ npm install nodemon -g
$ nodemon app.js

Answer 2

nodo supervisor es impresionante

para reiniciar el uso en guardar:

npm install supervisor -g
supervisor app.js

por Isaacs - http://github.com/isaacs/node-supervisor

Answer 3

He encontrado una manera sencilla:

delete require.cache['/home/shimin/test2.js']

Answer 4

nodemon se acercó por primera vez en una búsqueda en Google, y parece hacer el truco:

npm install nodemon -g
cd whatever_dir_holds_my_app
nodemon app.js

Answer 5

Si alguien todavía viene a esta pregunta y quiere resolverlo usando sólo los módulos estándar que hice un sencillo ejemplo:

var process = require('process');
var cp = require('child_process');
var fs = require('fs');

var server = cp.fork('server.js');
console.log('Server started');

fs.watchFile('server.js', function (event, filename) {
    server.kill();
    console.log('Server stopped');
    server = cp.fork('server.js');
    console.log('Server started');
});

process.on('SIGINT', function () {
    server.kill();
    fs.unwatchFile('server.js');
    process.exit();
});

Este ejemplo es sólo para un archivo (server.js), pero se puede adaptar a varios archivos usando una gran variedad de archivos, un bucle for para obtener todos los nombres de archivo, o viendo un directorio:

fs.watch('./', function (event, filename) { // sub directory changes are not seen
    console.log(`restart server`);
    server.kill();
    server = cp.fork('server.js');    
})

Este código se hizo para Node.js 0.8 API, no está adaptado para algunas de las necesidades específicas, pero funcionará en algunas aplicaciones simples.

ACTUALIZACIÓN: Esta funcionalidad se implementa en mi módulo más simple , GitHub repo

Answer 6

Hay Nodo-Supervisor que se puede instalar mediante

npm install supervisor

http://github.com/isaacs/node-supervisor

Answer 7

Editar Mi respuesta es obsoleto. Node.js es una tecnología que cambia muy rápido.

I también se preguntó acerca de recarga módulos. He modificado node.js y he publicado la fuente en Github en nalply / nodo . La única diferencia es la require función. Tiene una segunda reload argumento opcional.

require(url, reload)

Para volver a cargar app.js en uso directorio actual

app = require("./app", true);

escribir algo como esto, y usted tiene Auto -reload:

process.watchFile(script_name, function(curr, prev) {
    module = reload(script_name, true);
});

El único problema que veo es la variable module, pero estoy trabajando en ello ahora.

Answer 8

Hubo un reciente sobre este tema en el nodo. js lista de correo. La respuesta corta es no, no es posible en la actualidad de auto-recarga archivos requeridos, pero varias personas han desarrollado parches que añadir esta función.

Answer 9

otra solución para este problema está utilizando siempre

  

Otra capacidad útil de siempre es que opcionalmente puede reiniciar   su aplicación cuando los archivos de origen han cambiado. Esto le libera   de tener que reiniciar manualmente cada vez que se agrega una característica o una solución   error. Para empezar siempre en este modo, usar la bandera w:

forever -w start server.js

Answer 10

nodemon es un grande. Acabo de añadir más parámetros para la depuración y las opciones de ver.

package.json

  "scripts": {
    "dev": "cross-env NODE_ENV=development nodemon --watch server --inspect ./server/server.js"
  }

El comando: nodemon --watch server --inspect ./server/server.js

Considerando lo siguiente:

--watch server reiniciar la aplicación al cambiar .js, .mjs, .coffee, .litcoffee, y los archivos en la carpeta .json server (subcarpetas incluidas).

--inspect Habilitar depuración remota.

./server/server.js El punto de entrada.

A continuación, agregue la siguiente configuración para launch.json (Código VS) y empezar a depurar cualquier momento.

{
    "type": "node",
    "request": "attach",
    "name": "Attach",
    "protocol": "inspector",
    "port": 9229
}

Tenga en cuenta que es mejor instalar nodemon como dev dependencia del proyecto. Así que los miembros de su equipo no es necesario instalarlo o recordar los argumentos de comandos, que acaba de npm run dev y empezar a cortar.

Vea más en docs nodemon: https://github.com/remy/nodemon # monitoreo en múltiples directorios

Answer 11

nodo-dev funciona muy bien. NPM install node-dev

Incluso se da una notificación de escritorio cuando el servidor se vuelve a cargar y dará éxito o errores en el mensaje.

se inicia la aplicación en línea de comandos con:

node-dev app.js

Answer 12

Aquí es un blog acerca Recarga caliente para el nodo. Proporciona una github Nodo rama que se puede utilizar para reemplazar su instalación de nodo para permitir caliente recarga.

Desde el blog:

var requestHandler = require('./myRequestHandler');

process.watchFile('./myRequestHandler', function () {
  module.unCacheModule('./myRequestHandler');
  requestHandler = require('./myRequestHandler');
}

var reqHandlerClosure = function (req, res) {
  requestHandler.handle(req, res);
}

http.createServer(reqHandlerClosure).listen(8000);

  

Ahora, cada vez que se modifica myRequestHandler.js, el código anterior se dará cuenta y reemplazar el RequestHandler local con el nuevo código. Cualquier solicitud existentes continuarán utilizando el código de edad, mientras que las nuevas solicitudes entrantes usarán el nuevo código. Todo sin necesidad de apagar el servidor, rebotando cualquier solicitud, matando prematuramente cualquier solicitud, o incluso depender de un equilibrador de carga inteligente.

Answer 13

Estoy trabajando en la fabricación de un nodo bastante pequeño "cosa" que es capaz de módulos de carga / descarga a voluntad (es así, es decir, usted podría ser capaz de reiniciar parte de su solicitud sin traer abajo toda la aplicación). Yo estoy incorporando un (muy tonto) gestión de la dependencia, por lo que si desea detener un módulo, todos los módulos que depende de que se detendrán también.

Hasta aquí todo bien, pero luego me encontré en el tema de cómo volver a cargar un módulo. Al parecer, uno puede simplemente quitar el módulo de la memoria caché "requerir" y tener el trabajo hecho. Ya que no estoy dispuesto a cambiar directamente el código fuente nodo, se me ocurrió con un muy hacky-hack que está: buscar en el seguimiento de la pila la última llamada a la "requieren" función, agarrar una referencia a él del campo "caché" and..well, suprimir la referencia al nodo:

    var args = arguments
    while(!args['1'] || !args['1'].cache) {
        args = args.callee.caller.arguments
    }
    var cache = args['1'].cache
    util.log('remove cache ' + moduleFullpathAndExt)
    delete( cache[ moduleFullpathAndExt ] )

Incluso más fácil, en realidad:

var deleteCache = function(moduleFullpathAndExt) {
  delete( require.cache[ moduleFullpathAndExt ] )
}

Al parecer, esto funciona muy bien. No tengo absolutamente ninguna idea de lo que los argumentos [ "1"] medios, pero se está haciendo su trabajo. Creo que los chicos nodo implementarán un día las instalaciones de recarga, así que supongo que por ahora esta solución es aceptable también. (Por cierto mi "cosa" estará aquí:. https://github.com/cheng81/wirez , ir allí en un par de semanas y debería ver lo que estoy hablando)

Answer 14

Se puede utilizar nodemon NPM . Y si está utilizando el generador expreso a continuación, puede utilizar este comando dentro de su carpeta de proyecto:

nodemon npm start

o usando el modo de depuración

DEBUG=yourapp:* nodemon npm start

También puede ejecutar directamente

nodemon your-app-file.js

Espero que esto ayuda.

Answer 15

solución a: http://github.com/shimondoodkin/node-hot-reload

Tenga en cuenta que usted tiene que cuidar por sí mismo de las referencias utilizadas.

Esto significa que si usted hizo: var x = require ( 'foo'); y = x; z = x.bar; y caliente recargado a él.

que significa que tiene que reemplazar las referencias almacenadas en x, y, z. en la función de devolución de llamada reaload caliente.

Algunas personas confunden recarga caliente con reinicio automático mi módulo nodejs-autorestart también tiene la integración advenedizo para permitir el inicio automático en el arranque. si usted tiene una pequeña aplicación reinicio automático está muy bien, pero cuando se tiene una gran aplicación en caliente de recarga es más adecuado. simplemente porque es más rápido de recarga caliente.

También me gusta mi módulo de nodo de entrada.

Answer 16

No es necesario el uso de nodemon u otras herramientas por el estilo. Sólo tiene que utilizar las capacidades de su IDE.

Probablemente es mejor IntelliJ WebStorm con función de recarga en caliente (servidor de recarga automática y navegador) para Node.js .

Answer 17

Aquí hay un método de baja tecnología para su uso en Windows. Poner esto en un archivo por lotes llamado serve.bat:

@echo off

:serve
start /wait node.exe %*
goto :serve

Ahora, en lugar de correr node app.js de su consola CMD, ejecute serve app.js.

Esto abrirá una nueva ventana de shell que ejecuta el servidor. El archivo por lotes bloqueará (debido a la /wait) hasta que se cierre la ventana de celda, en cuyo punto la consola CMD originales preguntará "Terminar proceso por lotes (S / N)?" Si su respuesta es "N" y luego se lanzó de nuevo al servidor.

Cada vez que desee reiniciar el servidor, cierre la ventana del servidor y la respuesta "N" en la consola CMD.

Answer 18

mi estructura de aplicación:

NodeAPP (folder)
   |-- app (folder)
      |-- all other file is here
   |-- node_modules (folder)
   |-- package.json
   |-- server.js (my server file)

instale primero recarga con este comando:

npm install [-g] [--save-dev] reload

entonces el cambio package.json :

"scripts": {
    "start": "nodemon -e css,ejs,js,json --watch app"
}

Ahora debe utilizar recarga en el archivo del servidor

var express = require('express');
var reload = require('reload');
var app = express();

app.set('port', process.env.PORT || 3000);

var server = app.listen(app.get('port'), function() {
    console.log( 'server is running on port ' + app.get('port'));
});

reload(server, app);

y por último cambio, al final de su respuesta enviar este guión

<script src="/reload/reload.js"></script>

Ahora se inicia su aplicación con este código:

npm start

Answer 19

Utilice esta:

function reload_config(file) {
  if (!(this instanceof reload_config))
    return new reload_config(file);
  var self = this;

  self.path = path.resolve(file);

  fs.watchFile(file, function(curr, prev) {
    delete require.cache[self.path];
    _.extend(self, require(file));
  });

  _.extend(self, require(file));
}

Todo lo que tiene que hacer ahora es:

var config = reload_config("./config");

Y config conseguirá automáticamente recargado:)

Answer 20

loaddir es mi solución para la carga rápida de un directorio, de forma recursiva.

puede volver

{ 'path/to/file': 'fileContents...' } o { path: { to: { file: 'fileContents'} } }

Tiene callback que se llamará cuando se cambia el archivo.

Se ocupa de situaciones donde los archivos son lo suficientemente grandes que watch es llamado antes de que se está escribiendo hecho.

He estado usando en proyectos de un año o así, y recientemente añadido promesas a él.

Me ayudan batalla prueba de ello!

https://github.com/danschumann/loaddir

Answer 21

Se puede usar auto-recarga para recargar el módulo sin apagar el servidor.

instalar

npm install auto-reload

ejemplo

data.json

{ "name" : "Alan" }

Test.js

var fs = require('fs');
var reload = require('auto-reload');
var data = reload('./data', 3000); // reload every 3 secs

// print data every sec
setInterval(function() {
    console.log(data);
}, 1000);

// update data.json every 3 secs
setInterval(function() {
    var data = '{ "name":"' + Math.random() + '" }';
    fs.writeFile('./data.json', data);
}, 3000);

Resultados:

{ name: 'Alan' }
{ name: 'Alan' }
{ name: 'Alan' }
{ name: 'Alan' }
{ name: 'Alan' }
{ name: '0.8272748321760446' }
{ name: '0.8272748321760446' }
{ name: '0.8272748321760446' }
{ name: '0.07935990858823061' }
{ name: '0.07935990858823061' }
{ name: '0.07935990858823061' }
{ name: '0.20851597073487937' }
{ name: '0.20851597073487937' }
{ name: '0.20851597073487937' }

Answer 22

otra solución simple es utilizar fs.readFile en lugar de utilizar requerir puede guardar un archivo de texto contaning un objeto JSON, y crear un intervalo en el servidor para recargar este objeto.

ventajas:

• hay necesidad de utilizar librerías externas
• relevante para la producción de (volver a cargar el archivo de configuración en el cambio)
• fácil de implementar

contras:

• no se puede volver a cargar un módulo - sólo un JSON que contiene los datos de valores clave

Answer 23

Para las personas que utilizan Vagrant y PhpStorm, archivo observador es un enfoque más rápido

• desactivar la sincronización inmediata de los archivos para ejecutar el comando sólo en guardar a continuación, crear un espacio para los archivos del * .js y directorios de trabajo y añadir este comando

  vagabundo ssh -c "reinicio /var/www/gadelkareem.com/forever.sh"

donde forever.sh es como

#!/bin/bash

cd /var/www/gadelkareem.com/ && forever $1 -l /var/www/gadelkareem.com/.tmp/log/forever.log -a app.js

Answer 24

Hace poco llegó a esta pregunta porque los sospechosos habituales no estaban trabajando con paquetes enlazados. Si eres como yo y están tomando ventaja de npm link durante el desarrollo de manera eficaz el trabajo en un proyecto que se compone de muchos paquetes, es importante que los cambios que se producen en las dependencias desencadenan una recarga también.

Después de haber probado el nodo-mon y PM2, incluso siguiendo sus instrucciones, además, para ver el node_modules carpeta, que todavía no se recuperó cambios. Aunque hay algunas soluciones personalizadas en las respuestas aquí, para algo como esto, un paquete separado es más limpio. Me encontré con nodo-dev hoy y funciona perfectamente sin ninguna opción o configuración.

Desde el Léame:

  

A diferencia de las herramientas como supervisor o nodemon no analiza el sistema de archivos para los archivos a ser vigilados. En su lugar se engancha a su Node requieren () para ver sólo los archivos que han sido realmente necesarias.

Answer 25

const cleanCache = (moduleId) => {
    const module = require.cache[moduleId];
    if (!module) {
        return;
    }
    // 1. clean parent
    if (module.parent) {
        module.parent.children.splice(module.parent.children.indexOf(module), 1);
    }
    // 2. clean self
    require.cache[moduleId] = null;
};

Answer 26

se utiliza el servidor dev Hoy en día WebPack con opción caliente. se puede añadir un guión como este en su package.json: "hot": "cross-env NODE_ENV=development webpack-dev-server --hot --inline --watch-poll",

y cada cambio en sus archivos se disparará automáticamente una recompilación