Como recarregar arquivos automaticamente no Node.js?

Alguma idéia de como eu poderia implementar um recarregamento automático de arquivos no Node.js. Estou cansado de reiniciar o servidor toda vez que altero um arquivo. Aparentemente, a require()função Node.js. não recarrega os arquivos se eles já tiverem sido solicitados, por isso preciso fazer algo assim:

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

E no arquivo app.js eu tenho:

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

Mas isso também não está funcionando - eu recebo um erro na process.compile()declaração dizendo que 'require' não está definido. process.compileestá avaliando o app.js , mas não tem idéia sobre os globais do node.js.

Uma boa alternativa atualizada supervisoré nodemon:

Monitore todas as alterações em seu aplicativo node.js. e reinicie automaticamente o servidor - perfeito para desenvolvimento

Para usar nodemon:

$ npm install nodemon -g
$ nodemon app.js

supervisor de nó é impressionante

uso para reiniciar ao salvar:

supervisor de instalação do npm -g
supervisor app.js

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

eu encontrei uma maneira simples:

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

Se alguém ainda chega a essa pergunta e quer resolvê-la usando apenas os módulos padrão, fiz um exemplo simples:

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

Este exemplo é apenas para um arquivo (server.js), mas pode ser adaptado a vários arquivos usando uma matriz de arquivos, um loop for para obter todos os nomes de arquivos ou assistindo a um diretório:

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

Este código foi criado para a API Node.js 0.8, não está adaptado para algumas necessidades específicas, mas funcionará em alguns aplicativos simples.

UPDATE: Esta funcionalidade é implementada no meu módulo simpleR , repositório GitHub

nodemon surgiu primeiro em uma pesquisa no google, e parece fazer o truque:

npm install nodemon -g
cd whatever_dir_holds_my_app
nodemon app.js

Há um Node-Supervisor que você pode instalar

npm install supervisor

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

Edit: Minha resposta é obsoleta. O Node.js é uma tecnologia que muda muito rapidamente.

Também me perguntei sobre recarregar módulos. Modifiquei o node.js e publiquei a fonte no Github em nalply / node . A única diferença é a função require. Ele tem um segundo argumento opcional reload.

require(url, reload)

Para recarregar app.jsno diretório atual, use

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

Escreva algo como isto e você terá o recarregamento automático :

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

O único problema que vejo é a variável module, mas estou trabalhando nisso agora.

nodemoné ótimo. Acabei de adicionar mais parâmetros para opções de depuração e observação.

package.json

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

O comando: nodemon --watch server --inspect ./server/server.js

Enquanto que:

--watch serverReinicie o aplicativo ao mudar .js, .mjs, .coffee, .litcoffee, e .jsonarquivos na serverpasta (incluído subpastas).

--inspect Ativar depuração remota.

./server/server.js O ponto de entrada.

Em seguida, adicione a seguinte configuração em launch.json(Código VS) e comece a depurar a qualquer momento.

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

Observe que é melhor instalar nodemoncomo dependência de desenvolvimento do projeto. Para que os membros da sua equipe não precisem instalá-lo ou lembre-se dos argumentos de comando, eles apenas npm run devcomeçam a invadir.

Veja mais em nodemondocumentos: https://github.com/remy/nodemon#monitoring-multiple-directories

Houve um tópico recente sobre esse assunto na lista de discussão node.js. A resposta curta é não, atualmente não é possível recarregar automaticamente os arquivos necessários, mas várias pessoas desenvolveram patches que adicionam esse recurso.

ainda outra solução para esse problema está usando para sempre

Outro recurso útil do Forever é que ele pode, opcionalmente, reiniciar seu aplicativo quando qualquer arquivo de origem for alterado. Isso evita que você precise reiniciar manualmente sempre que adicionar um recurso ou corrigir um bug. Para iniciar o Forever nesse modo, use o sinalizador -w:

forever -w start server.js

O node-dev funciona muito bem. npminstall node-dev

Ele também fornece uma notificação na área de trabalho quando o servidor é recarregado e fornece êxito ou erros na mensagem.

inicie seu aplicativo na linha de comando com:

node-dev app.js

Aqui está uma postagem de blog sobre o Hot Reloading for Node. Ele fornece uma ramificação do nó do github que você pode usar para substituir sua instalação do nó e ativar o recarregamento a quente.

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

Agora, sempre que você modificar myRequestHandler.js, o código acima notará e substituirá o requestHandler local pelo novo código. Quaisquer pedidos existentes continuarão a usar o código antigo, enquanto quaisquer novos pedidos recebidos usarão o novo código. Tudo sem desligar o servidor, rejeitar solicitações, interromper prematuramente quaisquer solicitações ou até mesmo confiar em um balanceador de carga inteligente.

Estou trabalhando para criar uma "coisa" de nó bastante pequeno que seja capaz de carregar / descarregar módulos à vontade (por exemplo, você poderá reiniciar parte do seu aplicativo sem desativar o aplicativo inteiro). Estou incorporando um gerenciamento de dependências (muito estúpido), de modo que, se você quiser parar um módulo, todos os módulos que dependem disso também serão parados.

Até agora tudo bem, mas então me deparei com a questão de como recarregar um módulo. Aparentemente, pode-se remover o módulo do cache "require" e concluir o trabalho. Desde que eu não estou interessado em alterar diretamente o código-fonte nó, eu vim com uma muito hacky-hack que é: procure no rastreamento de pilha a última chamada para a "exigir" função, pegue uma referência ao campo que é "cache" e..bem, exclua a referência para o nó:

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

Ainda mais fácil, na verdade:

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

Aparentemente, isso funciona muito bem. Não tenho absolutamente nenhuma idéia do que esses argumentos ["1"] significam, mas está fazendo seu trabalho. Eu acredito que o pessoal do nó implementará um recurso de recarga algum dia, então acho que por enquanto essa solução também é aceitável. (btw. minha "coisa" estará aqui: https://github.com/cheng81/wirez , vá lá em algumas semanas e você deverá ver do que estou falando)

Você pode usar o nodemon do NPM . E se você estiver usando o gerador Express, poderá usar este comando dentro da pasta do projeto:

nodemon npm start

ou usando o modo de depuração

DEBUG=yourapp:* nodemon npm start

você também pode executar diretamente

nodemon your-app-file.js

Espero que esta ajuda.

solução em: http://github.com/shimondoodkin/node-hot-reload

observe que você deve cuidar das referências usadas.

isso significa que se você fez: var x = require ('foo'); y = x; z = x.bar; e quente recarregado.

isso significa que você deve substituir as referências armazenadas em x, ye z. na função de retorno de chamada reaload quente.

algumas pessoas confundem recarga a quente com reinicialização automática, o módulo nodejs-autorestart também possui integração inicial para permitir o início automático na inicialização. se você tiver um pequeno aplicativo, a reinicialização automática é boa, mas quando você tem um aplicativo grande, a recarga a quente é mais adequada. simplesmente porque a recarga a quente é mais rápida.

Também gosto do meu módulo de entrada de nós.

Não é necessário usar nodemon ou outras ferramentas como essa. Basta usar os recursos do seu IDE.

Provavelmente melhor é IntelliJ WebStorm com característica de recarga quente (servidor automático e recarga browser) para node.js .

Aqui está um método de baixa tecnologia para uso no Windows. Coloque isso em um arquivo em lotes chamado serve.bat:

@echo off

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

Agora, em vez de executar node app.jsno seu cmd shell, execute serve app.js.

Isso abrirá uma nova janela do shell executando o servidor. O arquivo em lote será bloqueado (por causa do /wait) até que você feche a janela do shell; nesse momento, o cmd original perguntará "Terminar trabalho em lotes (S / N)?" Se você responder "N", o servidor será reiniciado.

Sempre que desejar reiniciar o servidor, feche a janela do servidor e responda "N" no shell do cmd.

minha estrutura de aplicativos:

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

primeiro instale o recarregamento com este comando:

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

altere package.json :

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

agora você deve usar recarregar no arquivo do servidor :

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

e para a última alteração, final da sua resposta envie este script :

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

agora inicie seu aplicativo com este código:

npm start

Usa isto:

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

Tudo o que você precisa fazer agora é:

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

E a configuração será recarregada automaticamente :)

loaddir é a minha solução para carregamento rápido de um diretório, recursivamente.

pode retornar

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

Tem o callbackque será chamado quando o arquivo for alterado.

Ele lida com situações em que os arquivos são grandes o suficiente para serem watchchamados antes de terminar a gravação.

Uso-o em projetos há um ano ou mais e recentemente acrescentei promessas a ele.

Ajude-me a testá-lo!

https://github.com/danschumann/loaddir

Você pode usar o recarregamento automático para recarregar o módulo sem desligar o servidor.

instalar

npm install auto-reload

exemplo

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

Resultado:

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

outra solução simples é usar fs.readFile em vez de exigir que você possa salvar um arquivo de texto contendo um objeto json e criar um intervalo no servidor para recarregar esse objeto.

profissionais:

• não há necessidade de usar bibliotecas externas
• relevante para a produção (recarregando o arquivo de configuração na mudança)
• fácil de implementar

contras:

• você não pode recarregar um módulo - apenas um json contendo dados de valor-chave

Para pessoas que usam o Vagrant e o PHPStorm, o observador de arquivos é uma abordagem mais rápida

• desative a sincronização imediata dos arquivos para que você execute o comando apenas em save, crie um escopo para os arquivos * .js e diretórios de trabalho e adicione este comando

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

onde forever.sh é como

#!/bin/bash

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

Recentemente, cheguei a essa pergunta porque os suspeitos comuns não estavam trabalhando com pacotes vinculados. Se você é como eu e está aproveitando npm linkdurante o desenvolvimento para trabalhar efetivamente em um projeto que é composto por muitos pacotes, é importante que as alterações que ocorrem nas dependências disparem uma recarga também.

Depois de tentar o node-mon e o pm2, mesmo seguindo as instruções para assistir adicionalmente à pasta node_modules, eles ainda não capturaram as alterações. Embora existam algumas soluções personalizadas nas respostas aqui, para algo assim, um pacote separado é mais limpo. Encontrei o node-dev hoje e funciona perfeitamente sem opções ou configurações.

No Leiame:

Ao contrário de ferramentas como supervisor ou nodemon, ele não verifica o sistema de arquivos em busca de arquivos a serem observados. Em vez disso, ele se conecta à função require () do Node para observar apenas os arquivos que foram realmente necessários.

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

Você pode fazer isso com a atualização do navegador . Seu aplicativo do nó é reiniciado automaticamente, sua página de resultados no navegador também é atualizada automaticamente. A desvantagem é que você deve colocar o snippet js na página gerada. Aqui está o repo para o exemplo de trabalho.

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}/` })
    }

});

Eu tentei o pm2 : a instalação também é fácil e fácil de usar; o resultado é satisfatório. No entanto, precisamos cuidar de qual edição do pm2 queremos. O pm 2 runtime é a edição gratuita, enquanto o pm2 plus e o pm2 enterprise não são gratuitos.

Quanto ao Strongloop , minha instalação falhou ou não foi concluída, portanto não pude usá-lo.

Atualmente, o servidor de desenvolvimento WebPack com opção hot é usado. você pode adicionar um script como este em seu package.json:"hot": "cross-env NODE_ENV=development webpack-dev-server --hot --inline --watch-poll",

e todas as alterações em seus arquivos acionarão uma recompilação automaticamente