Comment recharger automatiquement les fichiers dans Node.js?

Question

Toutes les idées sur la façon dont je pourrais mettre en œuvre un rechargement automatique des fichiers dans Node.js? Je suis fatigué de redémarrer le serveur à chaque fois que je change un fichier. Apparemment, la fonction require() de Node.js ne se recharge pas les fichiers si elles ont déjà été nécessaires, donc je dois faire quelque chose comme ceci:

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

Et dans le app.js fichier je:

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

Mais cela ne fonctionne pas aussi - je reçois une erreur dans la déclaration de process.compile() disant que « require » est pas défini. process.compile est evaling app.js , mais n'a pas la moindre idée sur les Node.js GLOBALS.

Answer 1

Une bonne mise à jour alternative à supervisor est nodemon :

  

Surveiller pour tout changement dans votre application Node.js et redémarre automatiquement le serveur - parfait pour le développement

Pour utiliser nodemon:

$ npm install nodemon -g
$ nodemon app.js

Answer 2

-noeud superviseur est impressionnant

pour redémarrer l'utilisation sur Enregistrer:

npm install supervisor -g
supervisor app.js

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

Answer 3

je l'ai trouvé un moyen simple:

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

Answer 4

nodemon est venu d'abord dans une recherche google, et il semble faire l'affaire:

npm install nodemon -g
cd whatever_dir_holds_my_app
nodemon app.js

Answer 5

Si quelqu'un vient encore à cette question et veut le résoudre en utilisant uniquement les modules standard que j'ai fait un exemple simple:

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

Cet exemple est que pour un seul fichier (server.js), mais peut être adapté à plusieurs fichiers en utilisant un tableau de fichiers, une boucle pour obtenir tous les noms de fichiers, ou en regardant un répertoire:

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

Ce code a été fait pour l'API Node.js 0.8, il n'est pas adaptée à certains besoins spécifiques, mais travailler dans certaines applications simples.

Mise à jour: Cette fonction est implémentée dans mon module simple, repo GitHub

Answer 6

Il y a nœud superviseur que vous pouvez installer par

npm install supervisor

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

Answer 7

Modifier Ma réponse est obsolète. Node.js est une technologie qui évolue très vite.

Je me demandais aussi sur rechargeant modules . Je Node.js et ai modifié publié la source sur GitHub nalply / nœud . La seule différence est la fonction require. Il a un second argument optionnel reload.

require(url, reload)

Pour recharger app.js dans l'utilisation du répertoire courant

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

Ecrire quelque chose comme ça, et vous avez auto -reload:

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

Le seul problème que je vois est la module variable mais je travaille maintenant.

Answer 8

Il y avait un href="http://groups.google.com/group/nodejs/browse_thread/thread/c9b82171d3c7aac2" récent fil sur ce sujet sur le nœud. liste de diffusion js. La réponse courte est non, il est actuellement pas automatiquement les fichiers nécessaires reload possibles, mais plusieurs personnes ont développé des patchs qui ajoutent cette fonction.

Answer 9

encore une autre solution pour ce problème utilise pour toujours

  

Une autre capacité utile est toujours qu'il peut éventuellement redémarrer   votre application lorsque les fichiers source ont changé. Cela vous libère   d'avoir à redémarrer manuellement chaque fois que vous ajoutez une fonction ou fixer une   punaise. Pour commencer Toujours dans ce mode, utilisez le drapeau -w:

forever -w start server.js

Answer 10

nodemon est un grand. Je viens d'ajouter plus de paramètres pour les options de débogage et de regarder.

package.json

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

La commande: nodemon --watch server --inspect ./server/server.js

Attendu que:

--watch server Redémarrez l'application lors de la modification .js, .mjs, .coffee, .litcoffee et fichiers .json dans le dossier server (sous-dossiers inclus).

--inspect Activer le débogage à distance.

./server/server.js Le point d'entrée.

Ensuite, ajoutez la configuration suivante à launch.json (code VS) et commencer à tout moment de débogage.

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

Notez qu'il est préférable d'installer nodemon comme la dépendance dev du projet. Ainsi, les membres de votre équipe ne ont pas besoin d'installer ou de se rappeler les arguments de commande, ils ont juste npm run dev et commencer à bidouiller.

En savoir plus sur nodemon docs: https://github.com/remy/nodemon # surveillance multiples répertoires

Answer 11

node-dev fonctionne très bien. npm install node-dev

Il donne même une notification de bureau lorsque le serveur est rechargé et donnera le succès ou des erreurs sur le message.

démarrer votre application en ligne de commande avec:

node-dev app.js

Answer 12

est un blog sur Rechargement chaud pour le nœud. Il fournit un github branche nœud que vous pouvez utiliser pour remplacer votre installation de nœud pour permettre à chaud rechargement.

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

  

Maintenant, chaque fois que vous modifiez myRequestHandler.js, le code ci-dessus avis et remplacer le RequestHandler local avec le nouveau code. Toute demande existantes continueront d'utiliser l'ancien code, alors que les nouvelles demandes entrantes utiliseront le nouveau code. Tout cela sans arrêter le serveur, rebondissant toutes les demandes, tuant prématurément toute demande, ou même en se basant sur un équilibreur de charge intelligente.

Answer 13

Je travaille à faire un nœud plutôt petit « chose » qui est capable de charger / décharger des modules à volonté (donc, à savoir que vous pourriez être en mesure de redémarrer une partie de votre application sans apporter l'application dans son intégralité). Je suis un INCORPORANT (très stupide) la gestion des dépendances, de sorte que si vous voulez arrêter un module, tous les modules qui dépend qui seront arrêtés aussi.

Jusqu'à présent, si bon, mais je suis tombé dans la question de savoir comment recharger un module. Apparemment, on pourrait tout simplement retirer le module du cache « besoin » et ont le travail. Depuis que je ne suis pas désireux de changer directement le code source de nœud, je suis venu avec très hacky-hack qui est: la recherche dans la pile trace le dernier appel à la fonction « exiger », prenez un référence à sa and..well de champ « cache », supprimer la référence au nœud:

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

Encore plus facile, en fait:

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

Apparemment, cela fonctionne très bien. Je n'ai absolument aucune idée de ce que les arguments [ « 1 »] signifie, mais il est fait son travail. Je crois que les gars de nœud mettre en place une installation de recharge un jour, donc je suppose que pour l'instant cette solution est trop acceptable. (BTW ma "chose" sera ici. https://github.com/cheng81/wirez , y aller dans quelques semaines et vous devriez voir ce que je parle)

Answer 14

Vous pouvez utiliser nodemon NPM . Et si vous utilisez le générateur express, vous pouvez utiliser cette commande dans votre dossier de projet:

nodemon npm start

ou en utilisant le mode de débogage

DEBUG=yourapp:* nodemon npm start

vous pouvez également exécuter directement

nodemon your-app-file.js

Espérons que cela aide.

Answer 15

solution

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

Notez que vous devez prendre soin par vous-même des références utilisées.

Cela signifie que si vous avez: var x = require ( 'foo'); y = x; z = x.bar; et chaud rechargées il.

cela signifie que vous devez remplacer les références stockées dans x, y et z. dans la fonction de rappel de reaload chaud.

certaines personnes confondent reload chaud avec redémarrage automatique mon module nodejs-autorestart a également une intégration arriviste pour permettre le démarrage automatique au démarrage. si vous avez un petit redémarrage automatique de l'application est très bien, mais quand vous avez une grande application reload chaude est plus approprié. tout simplement parce que reload est plus rapide à chaud.

Aussi j'aime mon module nœud entrée.

Answer 16

pas nécessaire d'utiliser nodemon ou d'autres outils comme ça. Il suffit d'utiliser les capacités de votre IDE.

Probablement meilleur est IntelliJ WebStorm avec fonction de rechargement à chaud (serveur automatique et reload navigateur) pour Node.js .

Answer 17

Voici une méthode basse technologie pour une utilisation dans Windows. Mettez cela dans un fichier batch appelé serve.bat:

@echo off

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

Maintenant, au lieu de courir node app.js de votre shell cmd, exécutez serve app.js.

Cela ouvrira une nouvelle fenêtre shell en cours d'exécution du serveur. Le fichier de commandes bloque (à cause du /wait) jusqu'à ce que vous fermez la fenêtre de shell, à quel point le shell cmd d'origine demandera « Terminate traitement par lots (Y / N)? » Si vous répondez « N », le serveur sera relancée.

Chaque fois que vous voulez redémarrer le serveur, fermez la fenêtre du serveur et de répondre à « N » dans le shell cmd.

Answer 18

ma structure d'application:

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

d'abord installer reload avec cette commande:

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

puis changer package.json :

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

maintenant, vous devez utiliser reload dans votre fichier serveur :

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

et pour le dernier changement, à la fin de votre réponse envoyer ce script :

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

maintenant commencer votre application avec ce code:

npm start

Answer 19

Utilisez ceci:

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

Tout ce que vous avez à faire est maintenant:

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

config sera automatiquement rechargées:)

Answer 20

loaddir est ma solution pour le chargement rapide d'un répertoire, récursive.

peut revenir

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

Il a callback qui sera appelée lorsque le fichier est modifié.

Il gère les situations où les fichiers sont assez grands que watch est appelé avant qu'ils ne soient faites par écrit.

Je l'ai utilisé dans des projets pour un an, et tout récemment ajouté des promesses à elle.

Aidez-moi test de combat, il!

https://github.com/danschumann/loaddir

Answer 21

Vous pouvez utiliser l'auto-recharge pour recharger le module sans arrêter le serveur.

install

npm install auto-reload

exemple

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

Résultat:

{ 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

Une autre solution simple est de utiliser fs.readFile au lieu d'utiliser nécessitent vous pouvez enregistrer un fichier texte contaning un objet JSON, et créer un intervalle sur le serveur pour recharger cet objet.

avantages:

• pas besoin d'utiliser libs externes
• pour la production correspondant (rechargeant fichier de configuration sur le changement)
• facile à mettre en œuvre

contre:

• vous ne pouvez pas recharger un module - juste un JSON contenant des données clé-valeur

Answer 23

Pour les personnes utilisant Vagrant et PHPStorm, watcher fichier est une approche plus rapide

• désactiver la synchronisation immédiate des fichiers afin que vous exécutez la commande que lors de l'enregistrement puis créer un champ pour le * .js fichiers et répertoires de travail et ajoutez cette commande

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

où forever.sh est comme

#!/bin/bash

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

Answer 24

Je suis venu récemment à cette question parce que les suspects habituels ne fonctionnaient pas avec les paquets liés. Si vous êtes comme moi et profitent de npm link au cours du développement de travailler efficacement sur un projet qui est composé de plusieurs paquets, il est important que les changements qui se produisent dans les dépendances déclenchent une recharge aussi bien.

Après avoir mon nœud et PM2 essayé, même après leurs instructions pour regarder en outre le dossier node_modules, ils ont quand même ne capte pas les changements. Bien qu'il existe des solutions sur mesure dans les réponses ici, quelque chose comme ça, un paquet séparé est plus propre. Je suis tombé sur noeud-dev aujourd'hui et il fonctionne parfaitement sans aucune option ou configuration.

Dans le Readme:

  

Contrairement aux outils comme superviseur ou nodemon il ne scanne pas le système de fichiers pour les fichiers à surveiller. Au contraire, il accroche dans la fonction de nœud require () pour voir uniquement les fichiers qui ont été effectivement nécessaires.

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

Aujourd'hui WebPack serveur dev avec option chaude est utilisée. vous pouvez ajouter un script comme celui-ci dans votre package.json: "hot": "cross-env NODE_ENV=development webpack-dev-server --hot --inline --watch-poll",

et tout changement dans vos fichiers déclenchera automatiquement une recompilation