Como fazer arquivos de carga automática no Node.js?

Question

Alguma idéia de como eu poderia implementar um conjunto de arquivos automaticamente no Node.js? Estou cansado de reiniciar o servidor toda vez que altero um arquivo. Aparentemente node.js ' require() A função não recarregue os arquivos se eles já foram necessários, então eu 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 App.js Arquivo que 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 - recebo um erro no process.compile() declaração dizendo que 'requer' não está definido. process.compile está avaliando o App.js, mas não tem idéia dos globais node.js.

Answer 1

Uma boa alternativa a ser atualizada a supervisor é nodemon:

Monitore qualquer alteração no seu aplicativo Node.js e reinicie automaticamente o servidor - perfeito para desenvolvimento

Usar nodemon:

$ npm install nodemon -g
$ nodemon app.js

Answer 2

Node-supervisor é incrível

Uso para reiniciar o SAVE:

npm install supervisor -g
supervisor app.js

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

Answer 3

Eu encontrei uma maneira simples:

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

Answer 4

Nodemon surgiram primeiro em uma pesquisa no Google, e parece fazer o truque:

npm install nodemon -g
cd whatever_dir_holds_my_app
nodemon app.js

Answer 5

Se alguém ainda chegar a esta pergunta e quiser 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 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 feito para o Node.js 0.8 API, ele não é adaptado para algumas necessidades específicas, mas funcionará em alguns aplicativos simples.

ATUALIZAÇÃO: Este funcional é implementado no meu módulo mais simples, Repo Github

Answer 6

Existe um supervisor de nó que você pode instalar

npm install supervisor

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

Answer 7

Editar: Minha resposta é obsoleta. O Node.js é uma tecnologia muito rápida.

Eu também me perguntei sobre recarregar módulos. Eu modifiquei o Node.js e publiquei a fonte no GitHub em nalply/nó. A única diferença é a função require. Tem um segundo argumento opcional reload.

require(url, reload)

Para recarregar app.js no uso do diretório atual

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

Escreva algo assim, e você tem auto-recarregar:

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.

Answer 8

Houve um recente fio sobre esse assunto na lista de discussão do Node.js. A resposta curta é não, atualmente não é possível arquivos necessários para relojo automático, mas várias pessoas desenvolveram patches que adicionam esse recurso.

Answer 9

Mais uma solução para esse problema é usar para todo sempre

Outra capacidade útil para sempre é que ele pode reiniciar opcionalmente seu aplicativo quando quaisquer arquivos de origem foram alterados. Isso libera você de ter que reiniciar manualmente cada vez que adicionar um recurso ou consertar um bug. Para começar para sempre neste modo, use a bandeira -w:

forever -w start server.js

Answer 10

nodemon é um ótimo. Acabei de adicionar mais parâmetros para depurar e assistir opções.

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:

--watch server Reinicie o aplicativo ao mudar .js, .mjs, .coffee, .litcoffee, e .json arquivos no server pasta (subpastas incluídas).

--inspect Ativar depuração remota.

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

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

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

Observe que é melhor instalar nodemon como dependência do projeto do projeto. Portanto, os membros da sua equipe não precisam instalá -lo ou lembrar dos argumentos de comando, eles apenas npm run dev e comece a hackear.

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

Answer 11

Node-Dev funciona muito bem. npm install node-dev

Até fornece uma notificação de desktop quando o servidor é recarregado e dará sucesso ou erros na mensagem.

Inicie seu aplicativo na linha de comando com:

node-dev app.js

Answer 12

Aqui é um post sobre recarregar a quente para o Node. Fornece a Ramificação do Nó do Github que você pode usar para substituir sua instalação do nó para ativar a recarga 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ê modifica o MyReQuestHandler.js, o código acima notará e substituirá o requestHandler local pelo novo código. Quaisquer solicitações existentes continuarão a usar o código antigo, enquanto quaisquer novas solicitações de entrada usarão o novo código. Tudo sem desligar o servidor, saltar qualquer solicitação, matar prematuramente quaisquer solicitações ou mesmo confiar em um balanceador de carga inteligente.

Answer 13

Estou trabalhando para criar um nó pequeno "coisa" que seja capaz de carregar/descarregar módulos à vontade (então, ou seja, você pode reiniciar parte do seu aplicativo sem reduzir o aplicativo inteiro). Estou incorporando um gerenciamento (muito estúpido) de dependência, para que, se você quiser parar um módulo, todos os módulos que dependem disso também serão interrompidos.

Até agora, tudo bem, mas depois tropecei na questão de como recarregar um módulo. Aparentemente, pode -se remover o módulo do cache "requer" e fazer o trabalho. Como não estou interessado em mudar diretamente o código -fonte do nó, criei um muito Hacky-Hack isto é: Pesquise no rastreamento da pilha A última chamada para a função "requer", obtenha uma referência ao seu campo "cache" e ... bem, exclua a referência ao 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"] significa, mas está fazendo seu trabalho. Eu acredito que os caras do nó implementarão uma instalação 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ê deve ver do que estou falando)

Answer 14

Você pode usar Nodemon a partir de Npm. E se você estiver usando o Express Generator, 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 correr diretamente

nodemon your-app-file.js

Espero que isso ajude.

Answer 15

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

Observe que você precisa cuidar sozinho das referências usadas.

Isso significa que, se você fez: var x = requer ('foo'); y = x; z = x.bar; e a quente recarregou.

Isso significa que você deve substituir as referências armazenadas em x, y e z. na função de retorno de chamada real e reaload.

Algumas pessoas confundem recarregar a quente com reiniciar automaticamente meu módulo NodeJS-Autorestart também possui integração iniciante para ativar o início automático. Se você possui um pequeno aplicativo, o reinício automático é bom, mas quando você tem um grande aplicativo Recaroad, é mais adequado. Simplesmente porque a recarga quente é mais rápida.

Também gosto do meu módulo de fluxo de nó.

Answer 16

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

Provavelmente o melhor é Intellij Webstorm com o recurso de recarga a quente (servidor automático e recarga do navegador) para node.js.

Answer 17

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

@echo off

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

Agora em vez de correr node app.js Do seu shell cmd, corra serve app.js.

Isso abrirá uma nova janela do shell executando o servidor. O arquivo em lote será bloqueado (devido ao /wait) Até você fechar a janela da concha, em que ponto o shell CMD original perguntará "Terminar o trabalho em lote (S/N)?" Se você responder "n", o servidor será relançado.

Cada vez que você deseja reiniciar o servidor, feche a janela do servidor e responda "n" no shell CMD.

Answer 18

minha estrutura de aplicativo:

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

primeiro instalação recarregar Com este comando:

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

então mude package.json:

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

Agora você deve usar recarregar em seu arquivo de 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 mudança, final da sua resposta, envie isso roteiro:

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

Agora inicie seu aplicativo com este código:

npm start

Answer 19

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 que você precisa fazer agora é:

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

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

Answer 20

LoadDir é minha solução para carregar rápido um diretório, recursivamente.

pode retornar

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

Tem callback que será chamado quando o arquivo for alterado.

Ele lida com situações em que os arquivos são grandes o suficiente para que watch é chamado antes de terminar de escrever.

Eu o uso em projetos há mais ou menos um ano, e recentemente adicionei promessas a ele.

Ajude -me a testar a batalha!

https://github.com/danschumann/loaddir

Answer 21

Você pode usar o Auto-Relload 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' }

Answer 22

Outra solução simples é Use fs.readfile em vez de usar requerVocê pode salvar um arquivo de texto que contém um objeto JSON e criar um intervalo no servidor para recarregar esse objeto.

Prós:

• Não há necessidade de usar libs externas
• relevante para a produção (recarregando o arquivo de configuração na alteração)
• fácil de implementar

contras:

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

Answer 23

Para pessoas que usam Vagrant e Phpstorm, Vigilante do arquivo é uma abordagem mais rápida

• Desative a sincronização imediata dos arquivos para que você execute o comando apenas em salvar e criar um escopo para os arquivos *.js e diretórios de trabalho e adicionar este comando

  Vagrant ssh -c "/var/www/gadelkareem.com/forever.sh reiniciar"

onde sempre.sh é como

#!/bin/bash

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

Answer 24

Recentemente, cheguei a essa pergunta porque os suspeitos habituais não estavam trabalhando com pacotes vinculados. Se você é como eu e está aproveitando npm link Durante o desenvolvimento para trabalhar efetivamente em um projeto composto por muitos pacotes, é importante que as mudanças que ocorram nas dependências também acionem um recarregamento.

Depois de experimentar o Node-Mon e o PM2, mesmo seguindo suas instruções para assistir à pasta Node_modules, elas ainda não obtiveram alterações. Embora existam algumas soluções personalizadas nas respostas aqui, para algo assim, um pacote separado é mais limpo. Eu me deparei nó-dev hoje e funciona perfeitamente sem nenhuma opção ou configuração.

Do readme:

Em contraste com ferramentas como supervisor ou nodemon, ele não digitaliza o sistema de arquivos para que os arquivos sejam assistidos. Em vez disso, ele se conecta à função de requisição do nó () para assistir apenas aos arquivos que foram realmente necessários.

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

Atualmente, o WebPack Dev Server com opção quente é usado. Você pode adicionar um script como este no seu package.json: "hot": "cross-env NODE_ENV=development webpack-dev-server --hot --inline --watch-poll",

E todas as alterações em seus arquivos desencadearão um recompile automaticamente