Come auto-caricare i file in Node.js?

Question

Tutte le idee su come avrei potuto implementare un auto-ricarica di file in Node.js? Sono stanco di riavviare il server ogni volta che cambio un file. A quanto pare la funzione require() Node.js' non ricaricare i file se già sono stati richiesti, quindi ho bisogno di fare qualcosa di simile:

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 );

E nel app.js file che ho:

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

Ma anche questo non sta funzionando - ottengo un errore nella dichiarazione process.compile() dicendo che 'require' non è definito. process.compile è evaling app.js , ma non ha alcun indizio circa le Node.JS globali.

Answer 1

Una buona, fino a data alternativa per supervisor è nodemon :

  

Controlla per eventuali modifiche nell'applicazione node.js e automaticamente riavviare il server - ideale per lo sviluppo

Per usare nodemon:

$ npm install nodemon -g
$ nodemon app.js

Answer 2

node-supervisore è impressionante

Utilizzo per riavviare il salvataggio:

npm install supervisor -g
supervisor app.js

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

Answer 3

Ho trovato un modo semplice:

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

Answer 4

nodemon è venuto prima di una ricerca su Google, e sembra fare il trucco:

npm install nodemon -g
cd whatever_dir_holds_my_app
nodemon app.js

Answer 5

Se qualcuno viene ancora a questa domanda e vuole risolverlo utilizzando solo i moduli standard che ho fatto un semplice esempio:

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();
});

Questo esempio è solo per un file (server.js), ma può essere adattato a più file utilizzando una matrice di file, un ciclo for per ottenere tutti i nomi dei file, o guardando una directory:

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

Questo codice è stato fatto per Node.js 0,8 API, essa non è adatta per alcune esigenze specifiche, ma funziona in alcune applicazioni semplici.

UPDATE: Questa funzionalità è implementata nel mio modulo semplici , GitHub repo

Answer 6

C'è Node-supervisore che è possibile installare da

npm install supervisor

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

Answer 7

Modifica La mia risposta è obsoleto. Node.js è una tecnologia molto rapida evoluzione.

Ho anche domandato circa ricaricamento moduli. Ho modificato node.js e hanno pubblicato la sorgente a Github all'indirizzo nalply / nodo . L'unica differenza è la funzione require. Ha un secondo reload argomento opzionale.

require(url, reload)

Per ricaricare app.js in uso directory corrente

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

scrivere qualcosa del genere, e si dispone di auto -reload:

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

L'unico problema che vedo è il module variabile, ma sto lavorando ad ora.

Answer 8

C'è stato un recente infilare su questo argomento sul nodo. js mailing list. La risposta breve è no, non è attualmente possibile file necessari auto-ricarica, ma diverse persone hanno sviluppato patch che aggiungono questa funzionalità.

Answer 9

un'altra soluzione per questo problema sta usando sempre

  

Un'altra capacità utile di sempre è che può opzionalmente riavvio   l'applicazione quando i file di origine sono cambiate. In questo modo si libera   da dover riavviare manualmente ogni volta che si aggiunge una caratteristica o fissare un   bug. Per iniziare Sempre in questa modalità, utilizzare il flag -w:

forever -w start server.js

Answer 10

nodemon è un grande. Ho solo aggiungere più parametri per il debug e guardare le opzioni.

package.json

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

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

considerando quanto segue:

--watch server riavviare l'applicazione quando si cambia .js, .mjs, .coffee, .litcoffee, ei file nella cartella .json server (sottocartelle comprese).

--inspect Attiva debug remoto.

./server/server.js Il punto di ingresso.

Quindi aggiungere la seguente configurazione per launch.json (Codice VS) e avviare il debug in qualsiasi momento.

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

Si noti che è meglio installare nodemon come dev dipendenza del progetto. Così i membri del team non hanno bisogno di installare o ricordare gli argomenti del comando, hanno appena npm run dev e iniziare l'hacking.

Vedere anche sulla documentazione nodemon: https://github.com/remy/nodemon # monitoraggio a multiple-directory

Answer 11

node-dev grandi opere. npm install node-dev

Si dà anche un messaggio sul desktop quando il server viene ricaricato e darà successo o errori sul messaggio.

inizia la tua app su riga di comando con:

node-dev app.js

Answer 12

Qui è un post su Ricarica calda per nodo. Esso fornisce un ramo github Nodo che è possibile utilizzare per sostituire l'installazione del Nodo per abilitare Hot Ricarica.

Dal 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);

  

Ora, ogni volta che si modifica myRequestHandler.js, il codice di cui sopra se ne accorgerà e sostituire il requestHandler locale con il nuovo codice. Eventuali richieste esistenti continueranno a utilizzare il vecchio codice, mentre eventuali nuove richieste in arrivo utilizzeranno il nuovo codice. Il tutto senza spegnere il server, rimbalzando eventuali richieste, prematuramente uccidendo qualsiasi richiesta, o anche fare affidamento su un bilanciatore di carico intelligente.

Answer 13

Sto lavorando a fare un nodo piuttosto piccola "cosa" che è in grado di caricare / scaricare i moduli a volontà (così, vale a dire si potrebbe essere in grado di riavviare parte della vostra applicazione senza portare l'intera applicazione verso il basso). Sto incorpora un (molto stupida) la gestione delle dipendenze, in modo che se si desidera interrompere un modulo, saranno fermati anche tutti i moduli che dipende da quella.

Fin qui tutto bene, ma poi mi sono imbattuto nel problema di come ricaricare un modulo. A quanto pare, si potrebbe semplicemente rimuovere il modulo dalla cache "richiedere" ed avere il lavoro fatto. Dal momento che non sono interessati a modificare direttamente il codice sorgente del nodo, mi si avvicinò con un molto hacky-hack che è: ricerca nella pila traccia l'ultima chiamata al "richiedere" la funzione, afferrare un riferimento alla sua "cache" campo and..well, eliminare il riferimento 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 ] )

Ancora più facile, in realtà:

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

A quanto pare, questo funziona bene. Non ho assolutamente idea di quello che gli argomenti [ "1"] significa, ma che sta facendo il suo lavoro. Credo che i ragazzi dei nodi attueranno un impianto di ricarica, un giorno, quindi credo che per ora questa soluzione è accettabile troppo. (Btw il mio "cosa" sarà qui:. https://github.com/cheng81/wirez , andate in un paio di settimane e si dovrebbe vedere di cosa sto parlando)

Answer 14

È possibile utilizzare nodemon NPM . E se si sta utilizzando generatore espresso allora si può utilizzare questo comando all'interno della cartella di progetto:

nodemon npm start

o utilizzando la modalità di debug

DEBUG=yourapp:* nodemon npm start

è anche possibile eseguire direttamente

nodemon your-app-file.js

Spero che questo aiuto.

Answer 15

soluzione a: http://github.com/shimondoodkin/node-hot-reload

Si noti che si deve prendere cura da solo dei riferimenti utilizzati.

Questo significa che se avete fatto: var x = require ( 'foo'); y = x; z = x.bar; e caldo ricaricato esso.

che significa che è necessario sostituire i riferimenti memorizzati in x, ye z. nella funzione di callback reaload caldo.

Alcune persone confondono ricarica caldo con riavvio automatico il mio modulo nodejs-autorestart ha anche l'integrazione upstart per abilitare l'avvio automatico al boot. se si dispone di una piccola applicazione riavvio automatico va bene, ma quando si ha un grande app ricarica calda è più adatto. semplicemente perché ricarica caldo è più veloce.

Inoltre mi piace il mio modulo nodo-afflusso.

Answer 16

Non è necessario usare nodemon o di altri strumenti del genere. Basta utilizzare le funzionalità del vostro IDE.

Probabilmente migliore è IntelliJ WebStorm con funzione di ricarica a caldo (automatico del server e aggiornare il browser) per node.js .

Answer 17

Ecco un metodo a bassa tecnologia per l'utilizzo in Windows. Mettere questo in un file batch denominato serve.bat:

@echo off

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

Ora, invece di correre node app.js dalla shell cmd, serve app.js eseguire.

Si aprirà una nuova finestra di shell in esecuzione il server. Il file batch bloccherà (a causa del /wait) fino a quando si chiude la finestra di shell, a quel punto la shell cmd originale chiederà "Termina processo batch (S / N)?" Se si risponde "N", quindi il server verrà rilanciato.

Ogni volta che si desidera riavviare il server, chiudere la finestra del server e rispondere "N" nella shell cmd.

Answer 18

la mia struttura app:

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

prima installare Ricarica con questo comando:

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

quindi modificare package.json :

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

Ora è necessario utilizzare ricarica nella tua file server :

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);

e per ultima modifica, fine della vostra risposta inviare questo lo script :

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

ora inizia la tua app con questo codice:

npm start

Answer 19

Utilizzare questa:

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));
}

Tutto quello che dovete fare ora è:

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

E config otterrà automaticamente ricaricato:)

Answer 20

loaddir è la mia soluzione per il caricamento rapido di una directory, in modo ricorsivo.

può restituire

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

Ha callback che verrà chiamato quando il file viene modificato.

Gestisce le situazioni in cui i file sono abbastanza grandi che watch viene chiamato prima di essere fatto per iscritto.

ho usato in progetti per un anno o giù di lì, e solo promesse recentemente aggiunto ad esso.

Aiutami prova battaglia esso!

https://github.com/danschumann/loaddir

Answer 21

È possibile utilizzare auto-reload per ricaricare il modulo senza spegnere il server.

install

npm install auto-reload

Esempio

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);

Risultato:

{ 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

un'altra soluzione semplice è quella di utilizzare fs.readFile invece di usare richiede è possibile salvare un file di testo contaning un oggetto JSON, e creare un intervallo sul server per ricaricare questo oggetto.

Pro:

• non c'è bisogno di utilizzare librerie esterne
• rilevanti per la produzione (ricaricare file di configurazione sul cambiamento)
• facile da implementare

cons:

• non si può caricare un modulo - solo un JSON contenente i dati chiave-valore

Answer 23

Per le persone che utilizzano Vagrant e PhpStorm, file di watcher è un approccio più veloce

• disattivare la sincronizzazione immediata dei file in modo che si esegue il comando solo salvare quindi creare un ambito per il * .js file e directory di lavoro e aggiungere questo comando

  vagabondo ssh -c "restart /var/www/gadelkareem.com/forever.sh"

dove forever.sh è come

#!/bin/bash

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

Answer 24

Recentemente ho venuto a questa domanda, perché i soliti noti non funzionavano con i pacchetti collegati. Se siete come me e sta prendendo vantaggio di npm link durante lo sviluppo per lavorare in modo efficace su un progetto che si compone di molti pacchetti, è importante che i cambiamenti che si verificano in dipendenze innescare un ricaricamento pure.

Dopo aver provato nodo-mon e PM2, anche seguendo le loro istruzioni per l'aggiunta a guardare la cartella node_modules, che ancora non prelevamento modifiche. Anche se ci sono alcune soluzioni personalizzate nelle risposte qui, per qualcosa di simile, un pacchetto separato è più pulita. Mi sono imbattuto in nodo-dev oggi e funziona perfettamente senza alcuna opzione o configurazione.

Dal Leggimi:

  

A differenza di strumenti come supervisore o nodemon non eseguire la scansione del file system per i file da guardare. Invece si aggancia in funzione del nodo require () per guardare solo i file che sono stati effettivamente necessarie.

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

Al giorno d'oggi WebPack Server dev con opzione calda viene utilizzata. è possibile aggiungere uno script come questo nella tua package.json: "hot": "cross-env NODE_ENV=development webpack-dev-server --hot --inline --watch-poll",

ed ogni cambiamento nei file innescherà una ricompilazione automaticamente