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 habe es satt, den Server jedes Mal neu zu starten, wenn ich eine Datei ändere. Anscheinend lädt die require()Funktion von Node.js keine Dateien 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');  
}

Dies funktioniert aber auch nicht - ich erhalte eine Fehlermeldung in der process.compile()Anweisung, dass 'require' nicht definiert ist. process.compilebewertet die app.js , hat aber keine Ahnung von den globalen node.js.

Eine gute bis Alternative auf dem neuesten Stand supervisorist nodemon:

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

Verwendung nodemon:

$ npm install nodemon -g
$ nodemon app.js

Node-Supervisor ist großartig

Verwendung zum Neustart beim Speichern:

npm Install 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']

Wenn noch jemand zu dieser Frage kommt und sie nur mit den Standardmodulen lösen möchte, 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 jedoch mithilfe eines Array von Dateien, einer for-Schleife zum Abrufen aller Dateinamen oder durch Überwachen eines Verzeichnisses an mehrere Dateien angepasst werden:

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 jedoch in einigen einfachen Apps.

UPDATE: Diese Funktion ist in meinem Modul simpleR , GitHub repo implementiert

nodemon tauchte zuerst bei einer Google-Suche auf und es scheint den Trick zu tun:

npm install nodemon -g
cd whatever_dir_holds_my_app
nodemon app.js

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

npm install supervisor

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

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

Ich habe mich auch gefragt, ob ich Module neu laden soll . Ich habe node.js geändert und die Quelle bei Github unter nalply / node veröffentlicht . Der einzige Unterschied ist die Funktion require. Es hat ein optionales zweites Argumentreload .

require(url, reload)

Nachladen app.js in das aktuelle Verzeichnis verwenden

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

Schreiben Sie 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 die Variable module, aber ich arbeite gerade daran.

nodemonist großartig. Ich füge einfach weitere Parameter zum Debuggen und Beobachten hinzu.

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

Wohingegen:

--watch serverStarten Sie die App beim Wechsel .js, .mjs, .coffee, .litcoffee, und .jsonDateien in derserver Ordner (Unterordner enthalten).

--inspect Aktivieren Sie das Remote-Debug.

./server/server.js Der Einstiegspunkt.

Fügen Sie 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, nodemonals Entwicklungsabhängigkeit des Projekts zu installieren . Ihre Teammitglieder müssen es also nicht installieren oder sich an die Befehlsargumente erinnern, sondern nurnpm run dev mit dem Hacken beginnen.

Weitere nodemonInformationen finden Sie in den Dokumenten: https://github.com/remy/nodemon#monitoring-multiple-directories

Es gab einen aktuellen Thread zu diesem Thema in der Mailingliste von node.js. Die kurze Antwort lautet "Nein". Derzeit ist es nicht möglich, erforderliche Dateien automatisch neu zu laden. Mehrere Benutzer haben jedoch Patches entwickelt, die diese Funktion hinzufügen.

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

Eine weitere nützliche Funktion von Forever besteht darin, dass Ihre Anwendung optional neu gestartet werden kann, wenn sich Quelldateien geändert haben. Dies erspart Ihnen den manuellen Neustart jedes Mal, wenn Sie eine Funktion hinzufügen oder einen Fehler beheben. Verwenden Sie das Flag -w, um Forever in diesem Modus zu starten:

forever -w start server.js

Node-Dev funktioniert großartig. npminstall node-dev

Es gibt sogar eine Desktop-Benachrichtigung, wenn der Server neu geladen wird, und gibt Erfolg oder Fehler in der Nachricht.

Starten Sie Ihre App in der Befehlszeile mit:

node-dev app.js

Hier ist ein Blog-Beitrag über Hot Reloading for Node. Es bietet einen Github-Knoten-Zweig , mit dem Sie Ihre Node-Installation 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);

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

Ich arbeite daran, ein ziemlich kleines Knoten-Ding zu erstellen, das Module nach Belieben laden / entladen kann (dh, Sie könnten einen Teil Ihrer Anwendung neu starten, ohne die gesamte App herunterzufahren). Ich baue ein (sehr dummes) Abhängigkeitsmanagement ein, sodass, wenn Sie ein Modul stoppen möchten, auch alle davon abhängigen Module gestoppt werden.

So weit so gut, aber dann bin ich auf die Frage gestoßen, wie man ein Modul neu lädt. Anscheinend könnte man das Modul einfach aus dem "erforderlichen" Cache entfernen und die Arbeit erledigen lassen. Da ich den Knotenquellcode nicht direkt ändern möchte , habe ich mir einen sehr hackigen Hack ausgedacht: Suchen Sie im Stack den letzten Aufruf der Funktion "require" und suchen Sie einen Verweis auf das Feld "cache" 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:

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

Anscheinend funktioniert das ganz gut. Ich habe absolut keine Ahnung, was diese Argumente ["1"] bedeuten, aber es macht seinen Job. Ich glaube, dass die Node-Leute eines Tages eine Reload-Funktion implementieren werden, daher denke ich, dass diese Lösung vorerst auch akzeptabel ist. (Übrigens wird mein "Ding" hier sein: https://github.com/cheng81/wirez , geh in ein paar Wochen dorthin und du solltest sehen, wovon ich spreche)

Sie können nodemon von NPM verwenden . Wenn Sie den Express-Generator verwenden, können Sie diesen Befehl in Ihrem Projektordner verwenden:

nodemon npm start

oder im Debug-Modus

DEBUG=yourapp:* nodemon npm start

Sie können auch direkt ausführen

nodemon your-app-file.js

Ich hoffe das hilft.

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

Beachten Sie, dass Sie sich selbst um die verwendeten Referenzen kümmern müssen.

das heißt, wenn Sie dies getan haben: var x = require ('foo'); y = x; z = x.bar; und heiß nachgeladen.

Dies bedeutet, dass Sie die in x, y und z gespeicherten Referenzen ersetzen müssen. in der Hot-Reaload-Rückruffunktion.

Einige Leute verwechseln Hot Reload mit automatischem Neustart. Mein NodeJS-Autorestart-Modul verfügt auch über eine Upstart-Integration, um den automatischen Start beim Booten zu ermöglichen. Wenn Sie eine kleine App haben, ist ein automatischer Neustart in Ordnung, aber wenn Sie eine große App haben, ist ein Hot-Reload besser geeignet. einfach, weil heißes Nachladen schneller ist.

Auch mein Node-Inflow-Modul gefällt mir.

Es ist nicht erforderlich, nodemon oder andere solche Tools zu verwenden. Nutzen Sie einfach die Funktionen 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 eine Low-Tech-Methode zur Verwendung in Windows. Fügen Sie dies in eine Batch-Datei mit dem Namen ein serve.bat:

@echo off

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

Führen node app.jsSie jetzt aus, anstatt von Ihrer Cmd-Shell aus zu laufenserve app.js .

Dadurch wird ein neues Shell-Fenster geöffnet, in dem der Server ausgeführt wird. Die Batch-Datei wird blockiert (wegen der/wait ) bis Sie das Shell-Fenster schließen. An diesem Punkt fragt die ursprüngliche Cmd-Shell "Batch-Job beenden (J / N)?". Wenn Sie mit "N" antworten, wird der Server neu gestartet.

Schließen Sie jedes Mal, wenn Sie den Server neu starten möchten, das Serverfenster und antworten Sie in der cmd-Shell mit "N".

meine App-Struktur:

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

Installieren Sie zuerst reload mit diesem Befehl:

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

Ändern Sie dann package.json :

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

Jetzt müssen Sie reload in Ihrer Serverdatei 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 die letzte Änderung, Ende Ihrer Antwort senden Sie dieses Skript :

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

Starten Sie jetzt Ihre App mit diesem Code:

npm start

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

Jetzt müssen Sie nur noch Folgendes tun:

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

Und die Konfiguration wird automatisch neu geladen :)

loaddir ist meine Lösung zum schnellen rekursiven Laden eines Verzeichnisses.

kann zurückkehren

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

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

Es behandelt Situationen, in denen Dateien groß genug sind, um watchaufgerufen zu werden, bevor sie mit dem Schreiben fertig sind.

Ich benutze es seit ungefähr einem Jahr in Projekten und habe erst kürzlich Versprechen hinzugefügt.

Hilf mir, es zu testen!

https://github.com/danschumann/loaddir

Sie können das Modul automatisch neu laden, ohne den Server herunterzufahren.

Installieren

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 andere einfache Lösung besteht darin , fs.readFile anstelle von require zu verwenden. Sie können eine Textdatei speichern, die ein json-Objekt enthält, und auf dem Server ein Intervall erstellen, um dieses Objekt neu zu laden.

Profis:

• Keine Notwendigkeit, externe Bibliotheken 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 Benutzer von Vagrant und PHPStorm ist File Watcher ein schnellerer Ansatz

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

  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 auf diese Frage gekommen, weil die üblichen Verdächtigen nicht mit verknüpften Paketen arbeiteten. Wenn Sie wie ich sind und npm linkwährend der Entwicklung die Vorteile 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 erneutes Laden auslösen.

Nachdem sie Node-Mon und PM2 ausprobiert hatten und ihre Anweisungen zum zusätzlichen Überwachen des Ordners node_modules befolgt hatten, nahmen sie immer noch keine Änderungen auf. Obwohl die Antworten hier einige benutzerdefinierte Lösungen enthalten, ist für so etwas ein separates Paket sauberer. Ich bin heute auf Node-Dev gestoßen und es funktioniert perfekt ohne Optionen oder Konfiguration.

Aus der Readme:

Im Gegensatz zu Tools wie Supervisor oder Nodemon wird das Dateisystem nicht nach zu überwachenden Dateien durchsucht. Stattdessen wird die Funktion require () von Node eingebunden, um nur die tatsächlich benötigten Dateien zu überwachen.

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

Sie können dies mit Browser-Aktualisierung tun . Ihre Knoten-App wird automatisch neu gestartet. Ihre Ergebnisseite im Browser wird ebenfalls automatisch aktualisiert. Nachteil ist, dass Sie js Snippet auf die generierte Seite setzen müssen. Hier ist das Repo für das Arbeitsbeispiel.

const http = require('http');
const hostname = 'localhost';
const port = 3000;

const server = http.createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/html; charset=UTF-8');
    res.write('Simple refresh!');
    res.write(`<script src=${process.env.BROWSER_REFRESH_URL}></script>`);
    res.end();
})

server.listen(port, hostname, () => {
    console.log(`Server running at http://${hostname}:${port}/`);

    if (process.send) {
        process.send({ event: 'online', url: `http://${hostname}:${port}/` })
    }

});

Ich habe pm2 ausprobiert : Die Installation ist einfach und . Das Ergebnis ist zufriedenstellend. Wir müssen uns jedoch darum kümmern, welche Ausgabe von pm2 wir wollen. PM2 Runtime ist die kostenlose Edition, während PM2 Plus und PM2 Enterprise nicht kostenlos sind.

Bei Strongloop ist meine Installation fehlgeschlagen oder nicht abgeschlossen, sodass ich sie nicht verwenden konnte.

Heutzutage wird ein WebPack-Entwicklungsserver mit Hot-Option verwendet. Sie können ein solches Skript in Ihre package.json einfügen:"hot": "cross-env NODE_ENV=development webpack-dev-server --hot --inline --watch-poll",

und jede Änderung in Ihren Dateien löst automatisch eine Neukompilierung aus