Wie lade ich Dateien in Node.js automatisch neu?

Irgendwelche Ideen, wie ich ein automatisches Neuladen von Dateien in Node.js implementieren könnte? Ich bin es leid, den Server jedes Mal neu zu starten, wenn ich eine Datei ändere. Offenbar lädt require() function require() Node.js Dateien nicht neu, wenn sie bereits benötigt wurden. Daher muss ich Folgendes tun:

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

Und in der Datei app.js habe ich:

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

Aber das funktioniert auch nicht – ich bekomme einen Fehler in der process.compile() statement, der besagt, dass ‘require’ nicht definiert ist. process.compile liest die app.js aus , hat aber keine Ahnung von den nodes.js globals.

   

Eine gute, aktuelle Alternative zum supervisor ist nodemon :

Überwachen Sie alle Änderungen in Ihrer node.js-Anwendung und starten Sie den Server automatisch neu – ideal für die Entwicklung

Um nodemon :

 $ npm install nodemon -g $ nodemon app.js 

Node-Supervisor ist großartig

Verwendung, um beim Speichern neu zu starten:

 npm Installations-Supervisor -g
 Supervisor app.js

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

Ich habe einen einfachen Weg gefunden:

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

Nodemon kam zuerst in einer Google-Suche, und es scheint der Trick zu tun:

 npm install nodemon -g cd whatever_dir_holds_my_app nodemon app.js 

Wenn noch jemand auf diese Frage kommt und diese nur mit den Standardmodulen lösen will, habe ich ein einfaches Beispiel gemacht:

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

Dieses Beispiel gilt nur für eine Datei (server.js), kann aber mit einem Array von Dateien an mehrere Dateien angepasst werden, eine for-Schleife, um alle Dateinamen zu erhalten, oder indem Sie ein Verzeichnis ansehen:

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

Dieser Code wurde für die Node.js 0.8 API erstellt. Er ist nicht für bestimmte Anforderungen geeignet, funktioniert aber in einigen einfachen Anwendungen.

UPDATE: Dieses functional ist in meinem Modul simpleR , GitHub Repo implementiert

Es gibt Node-Supervisor, mit dem Sie installieren können

 npm install supervisor 

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

Bearbeiten: Meine Antwort ist veraltet. Node.js ist eine sich sehr schnell ändernde Technologie.

Ich habe mich auch gefragt, ob ich Module nachladen sollte . Ich habe node.js modifiziert und die Source bei Github bei nalply / node veröffentlicht . Der einzige Unterschied ist die function require . Es hat ein optionales zweites Argument neu zu reload .

 require(url, reload) 

Um app.js im aktuellen Verzeichnis neu zu laden, verwenden Sie

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

Schreibe so etwas, und du hast ein Auto- Reload:

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

Das einzige Problem, das ich sehe, ist das variable module , aber ich arbeite jetzt daran.

Eine weitere Lösung für dieses Problem ist die Verwendung für immer

Eine weitere nützliche function von Forever ist, dass es Ihre Anwendung gegebenenfalls neu starten kann, wenn Quelldateien geändert wurden. Dadurch müssen Sie nicht jedes Mal neu starten, wenn Sie eine function hinzufügen oder einen Fehler beheben. Um Forever in diesem Modus zu starten, verwenden Sie das Flag -w:

 forever -w start server.js 

Es gab einen aktuellen Thread zu diesem Thema in der Mailingliste node.js. Die kurze Antwort ist nein, es ist derzeit nicht möglich, erforderliche Dateien automatisch neu zu laden, aber einige Leute haben Patches entwickelt, die diese function hinzufügen.

Hier ist ein Blogbeitrag über Hot Reloading für Node. Es stellt einen GitHub Node-Zweig zur Verfügung , mit dem Sie Ihre Installation von Node ersetzen können, um das Hot Reloading zu aktivieren.

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

Jetzt, wenn Sie myRequestHandler.js ändern, wird der obige Code den lokalen requestHandler mit dem neuen Code erkennen und ersetzen. Alle vorhandenen Anforderungen werden weiterhin den alten Code verwenden, während alle neuen eingehenden Anforderungen den neuen Code verwenden. Alles, ohne den Server herunterzufahren, Anfragen abzucasting, Anfragen vorzeitig zu beenden oder sich sogar auf einen intelligenten Load Balancer zu verlassen.

Ich arbeite daran, ein ziemlich kleines Node “Ding” zu machen, das in der Lage ist, Module at-will zu laden / zu entladen (dh, du könntest einen Teil deiner Anwendung neu starten, ohne die ganze App herunter zu bringen). Ich füge ein (sehr dummes) Abhängigkeitsmanagement hinzu, so dass, wenn Sie ein Modul stoppen wollen, alle Module, die davon abhängen, ebenfalls gestoppt werden.

So weit, so gut, aber dann bin ich auf die Frage gestoßen, wie man ein Modul nachlädt. Anscheinend könnte man das Modul einfach aus dem Cache “require” entfernen und die Aufgabe erledigen. Da ich nicht scharf darauf bin, den Quellcode des Knotens direkt zu ändern, habe ich einen sehr Hacky-Hack gefunden, der lautet: suche im Stack den letzten Aufruf der “require” -function, nimm einen Verweis auf das “Cache” -Feld und … nun, löschen Sie den Verweis auf den Knoten:

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

Noch einfacher, eigentlich:

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

Anscheinend funktioniert das gut. Ich habe absolut keine Ahnung, was diese Argumente [“1”] bedeuten, aber es macht seine Arbeit. Ich glaube, dass die Knoten-Jungs eines Tages eine Nachlade-Einrichtung implementieren werden, also denke ich, dass diese Lösung im Moment auch akzeptabel ist. (Übrigens mein “Ding” wird hier sein: https://github.com/cheng81/wirez , geh dort in ein paar Wochen und du solltest sehen, wovon ich rede)

Node-Dev funktioniert großartig. npm install node-dev

Es gibt sogar eine Desktopbenachrichtigung, wenn der Server neu geladen wird und die Nachricht erfolgreich oder errorshaft ist.

Starten Sie Ihre App auf der Kommandozeile mit:

node-dev app.js

Lösung bei: http://github.com/shimondoodkin/node-hot-reload

Beachten Sie, dass Sie selbst auf die verwendeten Referenzen achten müssen.

das heißt, wenn du das getan hast: var x = require (‘foo’); y = x; z = x.bar; und heiß lud es neu.

es bedeutet, dass Sie die in x, y und z gespeicherten Referenzen ersetzen müssen. in der Hot-Reaload-Callback-function.

einige Leute verwechseln heißen Neuladen mit automatischem Neustart mein Nodejs-Autorestart-Modul hat auch Upstart-Integration, um den automatischen Start beim Booten zu ermöglichen. Wenn Sie eine kleine App haben, ist der automatische Neustart in Ordnung, aber wenn Sie eine große App haben, ist das Warmladen besser geeignet. einfach weil das Warmladen schneller ist.

Auch ich mag mein Knoten-Zufluss-Modul.

Nicht notwendig, um nodemon oder andere Tools wie diese zu verwenden. Nutze einfach die Fähigkeiten deiner IDE.

Am besten ist vielleicht IntelliJ WebStorm mit Hot-Reload-function (automatischer Server- und Browser-Reload) für node.js.

Benutze das:

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

Alles, was Sie jetzt tun müssen, ist:

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

Und config wird automatisch neu geladen 🙂

loaddir ist meine Lösung für das schnelle rekursive Laden eines Verzeichnisses.

kann zurückkehren

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

Es hat callback der aufgerufen wird, wenn die Datei geändert wird.

Es behandelt Situationen, in denen Dateien groß genug sind, dass die watch aufgerufen wird, bevor sie fertig geschrieben sind.

Ich benutze es seit ungefähr einem Jahr in Projekten und habe erst vor kurzem Zusagen dazu gemacht.

Hilf mir, es zu testen!

https://github.com/danschumann/loaddir

Sie können Auto-Reload verwenden, um das Modul neu zu laden, ohne den Server herunterzufahren.

Installieren

 npm install auto-reload 

Beispiel

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

Ergebnis:

 { 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' } 

Eine weitere einfache Lösung ist die Verwendung von fs.readFile anstelle von require. Sie können eine Textdatei speichern, die ein json-Objekt enthält, und auf dem Server ein Intervall erstellen, um dieses Objekt erneut zu laden.

Profis:

  • keine Notwendigkeit, externe libs zu verwenden
  • produktionsrelevant (Konfigurationsdatei bei Änderung neu laden)
  • einfach zu implementieren

Nachteile:

  • Sie können ein Modul nicht neu laden – nur einen JSON, der Schlüsselwertdaten enthält

Für Leute, die Vagrant und PHPStorm verwenden, ist File Watcher ein schnellerer Ansatz

  • Deaktivieren Sie die sofortige Synchronisierung der Dateien, sodass Sie den Befehl nur beim Speichern ausführen und dann einen Bereich für die * .js-Dateien und Arbeitsverzeichnisse erstellen und diesen Befehl hinzufügen

    vagrant ssh -c “/var/www/gadelkareem.com/forever.sh Neustart”

wo für immer.sh ist wie

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

Ich bin kürzlich zu dieser Frage gekommen, weil die üblichen Verdächtigen nicht mit verbundenen Paketen arbeiteten. Wenn Sie wie ich sind und npm link während der Entwicklung nutzen, um effektiv an einem Projekt zu arbeiten, das aus vielen Paketen besteht, ist es wichtig, dass Änderungen, die in Abhängigkeiten auftreten, auch ein Reload auslösen.

Nach dem Ausprobieren von node-mon und pm2, auch wenn sie ihren statementen zur zusätzlichen Überwachung des Ordners node_modules gefolgt waren, nahmen sie noch immer keine Änderungen auf. Obwohl in den Antworten hier einige benutzerdefinierte Lösungen enthalten sind, ist ein separates Paket sauberer. Ich bin heute auf node-dev gestoßen und es funktioniert perfekt ohne Optionen oder Konfiguration.

Aus der Readme-Datei:

Im Gegensatz zu Tools wie Supervisor oder Nodemon wird das Dateisystem nicht auf zu überwachende Dateien überprüft. Stattdessen hakt es sich in die require () -function von Node ein, um nur die Dateien zu sehen, die tatsächlich benötigt wurden.

nodemon ist großartig. Ich füge einfach weitere Parameter zum Debuggen und Beobachten von Optionen hinzu.

Paket.json

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

nodemon --watch server/**/*.js --inspect ./server/server.js

Wohingegen:

--watch server/**/*.js startet den server nur neu, wenn er .js-Dateien im Serverordner ändert.

--inspect Remote-Debug --inspect .

./server/server.js Der Einstiegspunkt.

launch.json dann die folgende Konfiguration zu launch.json (VS-Code) hinzu und starten Sie das Debuggen jederzeit.

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

Beachten Sie, dass es besser ist, nodemon als nodemon des Projekts zu installieren. Also müssen Ihre Teammitglieder es nicht installieren oder sich an die Befehlsargumente erinnern, sie starten nur npm run dev und starten Hacking.

Heutzutage wird der WebPack-Dev-Server mit der Hot-Option verwendet. Sie können ein Skript wie dieses in Ihrem Paket hinzufügen.json: "hot": "cross-env NODE_ENV=development webpack-dev-server --hot --inline --watch-poll",

und jede Änderung in Ihren Dateien triggers automatisch eine Neukompilierung aus