Comment recharger automatiquement les fichiers dans le nœud.js?

Nœud-superviseur est génial

Utilisation pour redémarrer à la sauvegarde:

npm install supervisor -g
supervisor app.js

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

J'ai trouvé un moyen simple:

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

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

npm install nodemon -g
cd whatever_dir_holds_my_app
nodemon app.js

Si quelqu'un arrive encore à cette question et veut la résoudre en utilisant uniquement les modules standard, 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 ne concerne qu'un seul fichier (serveur.js), mais peut être adapté à plusieurs fichiers en utilisant un tableau de fichiers, une boucle for 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é créé pour Node.API JS 0.8, il n'est pas adapté à certains besoins spécifiques, mais fonctionnera dans certaines applications simples.

Mise à jour: Cette fonctionnelle est mis en œuvre dans mon module plus simple, dépôt GitHub

Il y a un superviseur de noeud que vous pouvez installer par

npm install supervisor

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

Edit: Ma réponse est obsolète. Nœud.js est une technologie en évolution très rapide.

Je me suis aussi posé des questions sur le rechargement des modules. J'ai modifié le nœud.js et ont publié la source sur Github à nalply / node . La seule différence est la fonction require. Il a un deuxième argument optionnel reload.

require(url, reload)

Pour recharger app.js dans le répertoire courant, utilisez

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

Écrire quelque chose comme cela, et vous avez auto-recharger:

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

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

Une autre solution à ce problème consiste à utiliser forever

Une autre capacité utile de Forever est qu'il peut éventuellement redémarrer votre application lorsque les fichiers source ont changé. Cela vous permet de vous libérer d'avoir à redémarrer manuellement chaque fois que vous ajoutez une fonctionnalité ou de réparer un bogue. Pour démarrer définitivement dans ce mode, utilisez l'option-w:

forever -w start server.js

Il y avait un thread récent à propos de ce sujet sur le nœud.liste de diffusion js. La réponse courte est non, il n'est actuellement pas possible de recharger automatiquement les fichiers requis, mais plusieurs personnes ont développé des correctifs qui ajoutent cette fonctionnalité.

Voici un article de blog sur le rechargement à chaud pour Node. Il fournit une branche Github Node que vous pouvez utiliser pour remplacer votre installation de Node pour activer le rechargement à chaud.

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 remarquera et remplacera le requestHandler local avec le nouveau code. Toutes les demandes existantes continuent d'utiliser l'ancien code, tandis que les nouvelles demandes entrantes va utiliser le nouveau code. Tout sans arrêter le serveur, faire rebondir les demandes, tuer prématurément les demandes, ou même compter sur un équilibreur de charge intelligent.

Je travaille à faire une "chose" de nœud plutôt minuscule qui est capable de charger / décharger des modules à volonté(donc, c'est-à-dire que vous pourriez être en mesure de redémarrer une partie de votre application sans mettre toute l'application vers le bas). J'incorpore une gestion des dépendances (très stupide), de sorte que si vous voulez arrêter un module, tous les modules qui en dépendent seront également arrêtés.

Jusqu'à présent tout va bien, mais je suis tombé sur la question de savoir comment recharger un module. Apparemment, on pourrait simplement supprimer le module de le cache" require " et faire le travail. Comme je ne suis pas désireux de changer directement le code source du nœud, j'ai trouvé un très hacky-hack qui est: Rechercher dans la pile tracer le dernier appel à la fonction "require", saisir une référence à son champ "cache" et..Eh bien, supprimez 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 signifie cet argument["1"], mais il fait son travail. Je croyez que les gars du nœud implémenteront une installation de rechargement un jour, donc je suppose que pour l'instant cette solution est également acceptable. (btw. mon "truc" sera ici: https://github.com/cheng81/wirez , allez-y dans quelques semaines et vous devez voir de quoi je parle)

Nœud-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 les erreurs sur le message.

Démarrer votre application en ligne de commande avec:

node-dev app.js

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 l'avez fait : var x=require ('foo'); y=x; z = X. bar; et Hot reloaded il.

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

Certaines personnes confondent le rechargement à chaud avec le redémarrage automatique mon module NodeJS-autorestart a également une intégration upstart pour activer auto commencez au démarrage. si vous avez une petite application redémarrage automatique est bien, mais quand vous avez une grande application à chaud de rechargement est plus approprié. tout simplement parce que le rechargement à chaud est plus rapide.

J'aime aussi mon module node-inflow.

Pas nécessaire d'utiliser nodemon ou d'autres outils tels que. Utilisez simplement les capacités de votre IDE.

Le meilleur est probablement IntelliJ WebStorm avec la fonction de rechargement à chaud (rechargement automatique du serveur et du navigateur) pour le nœud .js .

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 maintenant est:

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

Et config sera automatiquement rechargé:)

Loaddir est ma solution pour le chargement rapide d'un répertoire, récursivement.

Peut retourner

{ '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 pour que watch soit appelé avant qu'ils n'aient terminé l'écriture.

Je l'utilise dans des projets depuis un an environ, et j'ai récemment ajouté des promesses.

Aidez-moi à tester la bataille c'!

Https://github.com/danschumann/loaddir

Vous pouvez utiliser auto-reload pour recharger le module sans arrêter le serveur.

Installer

npm install auto-reload

Exemple

Données.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' }

Une autre solution simple consiste à utiliser fs.readFile au lieu d'utiliser exiger vous pouvez enregistrer un fichier texte contenant un objet json et créer un intervalle sur le serveur pour recharger cet objet.

Avantages:

• pas besoin d'utiliser des libs
• pertinent pour la production (rechargement du fichier de configuration lors du changement)
• facile à mettre en œuvre

Inconvénients:

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

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

• Désactivez la synchronisation immédiate des fichiers afin que vous exécutiez la commande uniquement sur save puis créez une portée pour le *.fichiers js et répertoires de travail et ajoutez cette commande

  Vagrant ssh-c "/var/www/gadelkareem.com/forever.sh redémarrer "

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

Je suis récemment venu à cette question parce que les suspects habituels ne travaillaient pas avec des paquets liés. Si vous êtes comme moi et que vous profitez de npm link pendant le développement pour travailler efficacement sur un projet composé de nombreux paquets, il est important que les modifications qui se produisent dans les dépendances déclenchent également un rechargement.

Après avoir essayé node-mon et pm2, même en suivant leurs instructions pour regarder en plus le dossier node_modules, ils n'ont toujours pas ramassé les modifications. Bien qu'il existe des solutions personnalisées dans les réponses ici, pour quelque chose comme ça, un paquet séparé est plus propre. Je suis tombé sur node-dev aujourd'hui et cela fonctionne parfaitement sans aucune option ou configuration.

À partir du fichier Readme:

Contrairement aux outils comme supervisor ou nodemon, il n'analyse pas le système de fichiers pour les fichiers à surveiller. Au lieu de cela, il se connecte à la fonction require() de Node pour ne regarder que les fichiers qui ont été réellement requis.

nodemon est un grand. J'ajoute juste plus de paramètres pour le débogage et les options de visualisation.

paquet.json

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

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

Considérant ce qui suit:

--watch server/**/*.js Redémarrez uniquement le serveur lors du changement .fichiers js dans le dossier server.

--inspect Activer le débogage à distance.

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

Ajoutez ensuite la configuration suivante à launch.json (Code VS) et commencez le débogage à tout moment.

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

Notez qu'il est préférable d'installer nodemon comme dev dépendance du projet. Ainsi, les membres de votre équipe n'ont pas besoin de l'installer ou de se souvenir des arguments de commande, ils ont juste npm run dev et commencent à pirater.

De nos jours, le serveur de développement WebPack avec option hot est utilisé. 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 chaque modification de vos fichiers déclenchera automatiquement une recompilation

Vous pouvez utiliser nodemon à partir de MNP. Et si vous utilisez Express generator, vous pouvez utiliser cette commande dans votre dossier de projet:

nodemon npm start

Ou en utilisant le mode débogage

DEBUG=yourapp:* nodemon npm start

J'espère que cette aide.