Wie man Auto-Reload-Dateien in Node.js?

StackOverflow https://stackoverflow.com/questions/1972242

  •  21-09-2019
  •  | 
  •  

Frage

Alle Ideen, wie ich eine Auto-Reload von Dateien in Node.js implementieren könnte? Ich bin müde, um den Server neu zu starten jedes Mal, wenn ich eine Datei ändern. Offenbar Node.js' require() Funktion nicht Dateien nicht neu geladen, wenn sie bereits erforderlich gewesen, so dass ich, so etwas zu 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 app.js Datei ich habe: 

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

Aber das auch nicht funktioniert - ich erhalte einen Fehler in der process.compile() Erklärung, dass ‚erforderlich‘ ist nicht definiert. process.compile ist evaling die app.js , hat aber keine Ahnung über die node.js Globals.

War es hilfreich?

Lösung

Eine gute, aktuelle Alternative zu supervisor ist nodemon :

  

Monitor für alle Änderungen Ihrer node.js Anwendung und starten Sie den Server automatisch - ideal für die Entwicklung

Zur Verwendung nodemon: 

$ npm install nodemon -g
$ nodemon app.js

Andere Tipps

node-Supervisor ist genial

Nutzung neu zu starten, auf Speicher: 

npm install supervisor -g
supervisor app.js

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

i fand eine einfache Art und Weise: 

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

nodemon kam zuerst in einer Google-Suche, und es scheint, den Trick zu tun: 

npm install nodemon -g
cd whatever_dir_holds_my_app
nodemon app.js

Wenn jemand kommt noch auf diese Frage und will es lösen nur die Standardmodule mich mit einem einfachen Beispiel: 

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 ist nur für eine Datei (server.js), kann aber auf mehrere Dateien angepasst werden, um eine Reihe von Dateien unter Verwendung eines for-Schleife alle Dateinamen zu bekommen, oder durch ein Verzeichnis zu beobachten: 

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 gemacht für Node.js 0.8 API, ist es nicht für einige spezifische Bedürfnisse angepasst wird aber in einigen einfachen Anwendungen arbeiten.

UPDATE: Diese funktionale implementiert in meinem Modul einfacheren GitHub Repo

Es gibt Node-Betreuer, dass Sie installieren 

npm install supervisor

finden Sie unter http://github.com/isaacs/node-supervisor

Edit: Meine Antwort ist veraltet. Node.js ist eine sehr schnell verändernden Technologie.

Ich frage mich auch über Nachladen Module. Ich modifizierte node.js und haben die Quelle bei Github unter nalply / node veröffentlicht. Der einzige Unterschied ist die Funktion require. Es verfügt über ein optionales zweites Argument reload. 

require(url, reload)

nachladen app.js in aktuellem Verzeichnis Verwendung 

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

Schreiben so etwas, und Sie haben Auto -reload: 

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

Das einzige Problem, das ich sehe, ist der Variable module, aber ich arbeite an es jetzt.

Es gab einen aktuellen Thread zu diesem Thema auf dem Knoten. js Mailingliste. Die kurze Antwort ist nein, es ist derzeit nicht möglich, Auto-Reload-Dateien erforderlich, aber einige Leute Patches entwickelt haben, die diese Funktion hinzuzufügen.

noch eine andere Lösung für dieses Problem wird mit immer

  

Eine weitere nützliche Fähigkeit von Forever ist, dass es optional kann neu starten   Ihre Anwendung, wenn alle Quelldateien geändert haben. Das befreit Sie   um jedes Mal manuell neu starten aus, die fügen Sie eine Funktion oder ein fix   Fehler. Um immer in diesem Modus verwenden Sie das Flag -w zu starten: 

forever -w start server.js

nodemon ist ein großer. Ich füge nur mehr Parameter für die Fehlersuche und beobachten Optionen.

package.json 

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

Der Befehl: nodemon --watch server --inspect ./server/server.js

Während:

--watch server Neustart der App beim Wechsel .js, .mjs, .coffee, .litcoffee und .json Dateien im server Ordner (inklusive Unterordner).

--inspect Remote-Debug aktivieren.

./server/server.js Der Einstiegspunkt.

Dann fügen Sie die folgende Konfiguration zu launch.json (VS-Code) und starten Sie jederzeit das Debuggen. 

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

Beachten Sie, dass es besser ist, nodemon als DEV Abhängigkeit von Projekt zu installieren. So Ihre Teammitglieder brauchen es nicht zu installieren oder die Befehlsargumente erinnern, sie nur npm run dev und starten Hacking.

Sehen Sie mehr auf nodemon docs: https://github.com/remy/nodemon # Überwachung-multiple-Verzeichnisse

node-dev funktioniert super. npm install node-dev

Es gibt auch eine Desktop-Benachrichtigung, wenn der Server neu geladen wird und wird Erfolg oder Fehler auf der Nachricht geben.

Starten Sie Ihre App auf der Kommandozeile mit:

node-dev app.js

Hier eine Blog-Post über Hot Nachladen für Knoten. Es bietet eine Github Knoten Zweig , dass Sie Ihre Installation von Knoten verwenden können, ersetzen Hot aktivieren Nachladen.

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

Nun, Sie jederzeit myRequestHandler.js ändern, der obige Code wird die lokale Request mit dem neuen Code merken und ersetzen. Alle bestehenden Anfragen werden auch weiterhin den alten Code verwenden, während alle neuen eingehenden Anfragen werden den neuen Code verwenden. Alle, ohne den Server heruntergefahren, alle Anfragen prallen, vorzeitig, alle Anfragen zu töten, oder sogar auf einem intelligenten Load-Balancer angewiesen zu sein.

Ich arbeite einen eher kleinen Knoten „Ding“ auf machen, die Lade- / Entlade-Module-werden in der Lage ist (so, das heißt Sie können Teil Ihrer Anwendung der Lage sein, neu zu starten, ohne die gesamte App nach unten zu bringen). Ich bin ein (sehr dumm) Abhängigkeitsmanagement beinhaltet, so dass, wenn Sie ein Modul stoppen wollen, werden alle Module, die auf das hängt auch gestoppt werden.

So weit so gut, aber dann stolperte ich in die Frage, wie ein Modul neu zu laden. Offenbar kann man entfernen Sie das Modul aus der „require“ Cache und hat den Job zu erledigen. Da ich nicht direkt den Knoten Quellcode ändern keen, kam ich mit einem bis sehr Hacky-Hack, ist: in dem Stack-Trace den letzten Aufruf der „require“ Funktion, schnappen Sie sich einen suchen Bezug auf seinen „Cache“ Feld and..well, 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, tatsächlich: 

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

Offenbar funktioniert das ganz gut. Ich habe absolut keine Ahnung, was das Argument [ „1“] bedeutet, aber es ist ihre Arbeit zu tun. Ich glaube, dass der Knoten Jungs einen Reload Einrichtung einen Tag implementieren, so dass ich jetzt denke, dass diese Lösung auch akzeptabel ist. (Btw mein "Ding" wird hier:. https://github.com/cheng81/wirez , gehen dort in ein paar Wochen, und Sie sollten sehen, was ich rede)

Sie können mit nodemon NPM . Und wenn Sie Express-Generator verwenden, dann können Sie diesen Befehl in Ihrem Projektordner mit: 

nodemon npm start

oder mit Debug-Modus 

DEBUG=yourapp:* nodemon npm start

Sie können auch direkt

laufen 
nodemon your-app-file.js

Hope diese Hilfe.

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

Beachten Sie, dass Sie selbst der verwendeten Referenzen zu kümmern haben.

Das heißt, wenn Sie getan haben: var x = require ( 'foo'); y = x; z = x.bar; und heiß neu geladen es.

es bedeutet, dass Sie die Referenzen in x, y und z gespeichert ersetzen. in der heißen reaload Callback-Funktion.

einige Leute verwechseln heiß Reload mit automatischem Neustart mein NodeJS-automatischer Neustart Modul hat auch Emporkömmling Integration Autostart beim Booten zu aktivieren. Wenn Sie eine kleine app Auto-Restart haben, ist in Ordnung, aber wenn Sie eine große app heiß reload haben, ist besser geeignet. einfach, weil heißen reload ist schneller.

Auch ich wie mein Knoten-Zufluss-Modul.

Nicht nötig verwenden nodemon oder andere Werkzeuge wie die. Verwenden Sie einfach Fähigkeiten Ihrer IDE.

Wahrscheinlich am besten ist IntelliJ WebStorm mit heißer Reload-Funktion (automatischem Server und Browser neu laden) für node.js .

Hier ist ein Low-Tech-Verfahren zur Verwendung in Windows. Setzen Sie diese in einer Batch-Datei namens serve.bat: 

@echo off

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

Jetzt statt node app.js von Ihrem cmd Shell ausgeführt wird, führen serve app.js.

Dies wird ein neues Shell-Fenster auf den Server ausgeführt werden öffnen. Die Batch-Datei blockiert (wegen des /wait), bis Sie die Shell-Fenster zu schließen, bei dem die ursprünglichen cmd Shell fragt Punkt „Terminate Batch-Job (Y / N)?“ Wenn Sie „N“ dann der Server antworten neu gestartet werden.

Jedes Mal, wenn Sie möchten, den Server neu zu starten, in der Nähe des Server Fenster und Antwort "N" in dem cmd-Shell.

meine app Struktur: 

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

zuerst installieren reload mit diesem Befehl: 

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

dann ändern package.json : 

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

Jetzt müssen Sie reload in der Server-Datei verwenden : 

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

und für letzte Änderung, Ende Ihrer Antwort senden Sie dieses Skript : 

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

Sie jetzt Ihre App mit diesem Code starten: 

npm start

Verwenden Sie diese: 

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 automatisch wieder geladen werden:)

loaddir ist meine Lösung für schnelles Laden eines Verzeichnisses rekursiv.

können zurückkehren

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

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

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

Ich habe es in Projekten für ein Jahr mit oder so, und erst vor kurzem Versprechen hinzugefügt.

Helfen Sie mir Schlacht Test it!

https://github.com/danschumann/loaddir

Sie können Auto-Reload verwenden Sie das Modul ohne Herunterfahren des Servers neu zu laden.

install 

npm install auto-reload

Beispiel

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

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 es, verwenden fs.readFile anstelle der Verwendung erfordern Sie können eine Textdatei contaning ein JSON-Objekt speichern, und ein Intervall auf dem Server erstellen, um diese Aufgabe neu zu laden.

Vorteile:

  • keine Notwendigkeit, externe Bibliotheken zu verwenden,
  • relevant für die Produktion (config-Datei auf Änderung Nachladen)
  • einfach zu implementieren

Nachteile:

  • Sie können ein Modul neu geladen - nur ein json enthält Schlüsselwertdaten

Für Menschen, Vagrant und PhpStorm verwenden, Watcher Datei eine schnellere Annäherung

  • disable sofortige Synchronisierung der Dateien, so dass Sie den Befehl nur auf Sicht zu speichern dann einen Bereich für die Dateien Js * erstellen und Arbeitsverzeichnisse und fügen Sie diesen Befehl

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

wo forever.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 kam vor kurzem auf diese Frage, weil die üblichen Verdächtigen wurden nicht mit verknüpften Paketen arbeiten. Wenn Sie wie ich sind und an einem Projekt, um effektiv arbeiten Vorteil npm link während der Entwicklung nehmen, die aus vielen Paketen besteht, ist es wichtig, dass Änderungen, die in Abhängigkeiten auftreten einen Reload auch auslösen.

Nachdem versucht, Knoten-mon und PM2, auch ihre Anweisungen folgen für zusätzlich beobachten den node_modules Ordner, sie haben holen noch keine Änderungen auf. Obwohl es in den Antworten für so etwas wie diese hier, einige benutzerdefinierten Lösungen sind, ist ein separates Paket Reiniger. Ich kam über Knoten-dev heute und es funktioniert perfekt ohne Optionen oder Konfiguration.

Aus der Readme-Datei:

  

Im Gegensatz zu Tool wie Supervisor oder nodemon es nicht das Dateisystem scannt Dateien beobachtet werden. Stattdessen hakt es in Knoten des require () Funktion nur die Dateien zu sehen, die tatsächlich erforderlich sind. 

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

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

und jede Änderung Ihrer Dateien neu kompiliert auslösen automatisch

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top