Você constrói o aplicativo node.js com express v4.x e inicia seu aplicativo por npm start . Minha dúvida é como parar o aplicativo? Existe uma parada do NPM ?

EDIT para incluir o erro ao implementar npm stop

/home/nodetest2# npm stop

> nodetest2@0.0.1 stop /home/nodetest2
> pkill -s SIGINT nodetest2

pkill: invalid argument for option 's' -- SIGINT

npm ERR! nodetest2@0.0.1 stop: `pkill -s SIGINT nodetest2`
npm ERR! Exit status 2

Sim, o npm fornece um script de parada também:

npm help npm-scripts

prestop, stop, poststop: executado pelo comando npm stop.

Defina uma das opções acima em seu package.json e, em seguida, use npm stop

npm help npm-stop

Você pode fazer isso realmente simples, se você definir em app.js,

process.title = myApp;

E, então, em scripts.json,

"scripts": {
    "start": "app.js"
    , "stop": "pkill --signal SIGINT myApp"
}

Dito isso, se fosse eu, eu estaria usando pm2ou algo que automaticamente tratasse disso com base em um git push.

Todas as outras soluções aqui dependem do sistema operacional. Uma solução independente para qualquer sistema operacional usa socket.io da seguinte maneira.

package.json tem dois scripts:

"scripts": {
  "start": "node server.js",
  "stop": "node server.stop.js"
}

server.js - Seu material expresso usual vive aqui

const express = require('express');
const app = express();
const server = http.createServer(app);
server.listen(80, () => {
  console.log('HTTP server listening on port 80');
});

// Now for the socket.io stuff - NOTE THIS IS A RESTFUL HTTP SERVER
// We are only using socket.io here to respond to the npmStop signal
// To support IPC (Inter Process Communication) AKA RPC (Remote P.C.)

const io = require('socket.io')(server);
io.on('connection', (socketServer) => {
  socketServer.on('npmStop', () => {
    process.exit(0);
  });
});

server.stop.js

const io = require('socket.io-client');
const socketClient = io.connect('http://localhost'); // Specify port if your express server is not using default port 80

socketClient.on('connect', () => {
  socketClient.emit('npmStop');
  setTimeout(() => {
    process.exit(0);
  }, 1000);
});

Teste

npm start (para iniciar o seu servidor normalmente)

npm stop (isso irá parar o seu servidor em execução)

O código acima não foi testado (é uma versão reduzida do meu código, meu código funciona), mas espero que funcione como está. De qualquer forma, ele fornece a direção geral a ser tomada se você quiser usar o socket.io para parar o seu servidor.

Quando tentei a solução sugerida, percebi que o nome do meu aplicativo estava truncado. Eu li na process.titledocumentação do nodejs ( https://nodejs.org/docs/latest/api/process.html#process_process_title ) e diz

No Linux e no OS X, é limitado ao tamanho do nome binário mais o comprimento dos argumentos da linha de comando porque sobrescreve a memória argv.

Meu aplicativo não usa nenhum argumento, então posso adicionar esta linha de código ao meu app.js

process.title = process.argv[2];

e adicionar essas poucas linhas ao meu package.jsonarquivo

  "scripts": {
    "start": "node app.js this-name-can-be-as-long-as-it-needs-to-be",
    "stop": "killall -SIGINT this-name-can-be-as-long-as-it-needs-to-be"
  },

para usar nomes de processos realmente longos. npm starte o npm stoptrabalho, é claro npm stopque sempre encerrará todos os processos em execução, mas isso é bom para mim.

Este é um problema de versão mintty, como alternativa, use cmd. Para encerrar o processo do servidor, basta executar este comando:

    taskkill -F -IM node.exe

No MAC OS X (/ BSD): você pode tentar usar o comando lsof (list open files)

$ sudo lsof -nPi -sTCP:LISTEN

e entao

$ kill -9 3320

Verifique com netstat -nptl todos os processos

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.1:27017         0.0.0.0:*               LISTEN      1736/mongod     
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      1594/sshd       
tcp6       0      0 :::3977                 :::*                    LISTEN      6231/nodejs     
tcp6       0      0 :::22                   :::*                    LISTEN      1594/sshd       
tcp6       0      0 :::3200                 :::*                    LISTEN      5535/nodejs 

E simplesmente mata o processo pela referência PID .... No meu caso quero parar o 6231 / nodejs então executo o seguinte comando:

kill -9 6231

Aqui está outra solução que mistura ideias das respostas anteriores. Ele adota a abordagem de "processo de eliminação" enquanto trata da preocupação com a independência da plataforma.

Ele depende do pacote tree-kill para lidar com a eliminação da árvore de processos do servidor. Descobri que matar toda a árvore de processos é necessário em meus projetos porque algumas ferramentas (por exemplo babel-node) geram processos filhos. Se você só precisa matar um único processo, você pode substituir tree-kill com o built-inprocess.kill() método .

A solução é a seguinte (os primeiros dois argumentos para spawn()devem ser modificados para refletir a receita específica para executar seu servidor):

build / start-server.js

import { spawn } from 'child_process'
import fs from 'fs'

const child = spawn('node', [
  'dist/server.js'
], {
  detached: true,
  stdio: 'ignore'
})
child.unref()

if (typeof child.pid !== 'undefined') {
  fs.writeFileSync('.server.pid', child.pid, {
    encoding: 'utf8'
  })
}

build / stop-server.js

import fs from 'fs'
import kill from 'tree-kill'

const serverPid = fs.readFileSync('.server.pid', {
  encoding: 'utf8'
})
fs.unlinkSync('.server.pid')

kill(serverPid)

package.json

"scripts": {
  "start": "babel-node build/start-server.js",
  "stop": "babel-node build/stop-server.js"
}

Observe que esta solução desconecta o script de inicialização do servidor (ou seja npm start, retornará imediatamente e não bloqueará até que o servidor seja interrompido). Se você preferir o comportamento de bloqueio tradicional, simplesmente remova o options.detachedargumento para spawn()e a chamada para child.unref().

Se você já tentou ctrl + ce ainda não funciona, você pode tentar isso. Isso tem funcionado para mim.

1. Execute a linha de comando como administrador. Em seguida, execute o comando abaixo para encontrar o ID do processo (PID) que você deseja eliminar. Digite o seu número de porta em<yourPortNumber>

   netstat -ano | findstr :<yourPortNumber>

2. Então você executa este comando depois de identificar o PID.

   taskkill /PID <typeYourPIDhere> /F

Parabéns a @mit $ ingh de http://www.callstack.in/tech/blog/windows-kill-process-by-port-number-157

Se for muito simples, basta matar o processo ..

localmacpro$ ps
  PID TTY           TIME CMD
 5014 ttys000    0:00.05 -bash
 6906 ttys000    0:00.29 npm   
 6907 ttys000    0:06.39 node /Users/roger_macpro/my-project/node_modules/.bin/webpack-dev-server --inline --progress --config build/webpack.dev.conf.js
 6706 ttys001    0:00.05 -bash
 7157 ttys002    0:00.29 -bash

localmacpro$ kill -9 6907 6906

Para a máquina Windows (estou no Windows 10), se o comando CTRL + C (Cancelar / Abortar) no cli não funcionar, a tela aparecerá assim:

Tente pressionar ENTER primeiro (ou qualquer tecla faria) e depois CTRL + C e o processo atual perguntaria se você deseja encerrar o trabalho em lote:

Talvez CTRL + C termine apenas o processo pai, enquanto npm start é executado com outros processos filho. Não tenho certeza porque você precisa apertar aquela tecla extra antes de CTRL + C, mas funciona melhor do que fechar a linha de comando e começar novamente.

Um problema relacionado que você pode querer verificar: https://github.com/mysticatea/npm-run-all/issues/74

Para ambientes de produção, você deve usar Forever.js

É tão útil para iniciar e parar o processo do nó que você também pode listar os aplicativos em execução.

https://github.com/foreverjs/forever

Você pode usar pm2

https://pm2.keymetrics.io/docs/usage/quick-start/

após a instalação basta digitar no terminal

pm2 start app.js e depois

pm2 stop 0 para parar o seu servidor

Caso o seu arquivo json não tenha um script para parar o aplicativo, uma opção que utilizo é apenas pressionando ctrl + C no cmd.

Toda (3) solução é:

1- ctlr + C

2- no arquivo json escreva um script que pare

"scripts": {"stop": "killall -SIGINT este-nome-pode-ser-contanto-que-precisar-ser"},

* do que no comando write // npm stop //

3- Reinicie o pc

Você deve pressionar a combinação ctrl + z Meu sistema operacional é Ubuntu