Vous créez l'application node.js avec express v4.x, puis démarrez votre application par npm start . Ma question est de savoir comment arrêter l'application? Y a-t-il un arrêt npm ?

EDIT pour inclure l'erreur lors de la mise en œuvre de l' arrêt npm

/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

Oui, npm fournit également un script d'arrêt:

npm help npm-scripts

prestop, stop, poststop: Exécuté par la commande npm stop.

Définissez l'un des éléments ci-dessus dans votre package.json, puis utilisez npm stop

npm help npm-stop

Vous pouvez rendre cela vraiment simple si vous vous installez app.js,

process.title = monApp;

Et, ensuite dans scripts.json,

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

Cela dit, si c'était moi, j'utiliserais pm2ou quelque chose qui gèrerait automatiquement cela sur la base d'une poussée git.

Toutes les autres solutions ici dépendent du système d'exploitation. Une solution indépendante pour tout système d'exploitation utilise socket.io comme suit.

package.json a deux scripts:

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

server.js - Vos trucs express habituels vivent ici

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

Testez-le

npm start (pour démarrer votre serveur comme d'habitude)

npm stop (cela arrêtera maintenant votre serveur en cours d'exécution)

Le code ci-dessus n'a pas été testé (c'est une version réduite de mon code, mon code fonctionne) mais j'espère qu'il fonctionne tel quel. Dans tous les cas, il fournit la direction générale à suivre si vous souhaitez utiliser socket.io pour arrêter votre serveur.

Lorsque j'ai essayé la solution suggérée, j'ai réalisé que le nom de mon application était tronqué. J'ai lu process.titledans la documentation nodejs ( https://nodejs.org/docs/latest/api/process.html#process_process_title ) et il est dit

Sous Linux et OS X, il est limité à la taille du nom binaire plus la longueur des arguments de ligne de commande car il écrase la mémoire argv.

Mon application n'utilise aucun argument, je peux donc ajouter cette ligne de code à mon app.js

process.title = process.argv[2];

puis ajoutez ces quelques lignes à mon package.jsonfichier

  "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"
  },

pour utiliser des noms de processus très longs. npm startet le npm stoptravail, bien sûr, npm stopmettra toujours fin à tous les processus en cours d'exécution, mais cela me convient.

Ceci est un problème de version mintty ou utilisez cmd. Pour tuer le processus serveur, exécutez simplement cette commande:

    taskkill -F -IM node.exe

Sous MAC OS X (/ BSD): vous pouvez essayer d'utiliser la commande lsof (lister les fichiers ouverts)

$ sudo lsof -nPi -sTCP:LISTEN

et donc

$ kill -9 3320

Vérifier avec netstat -nptl tous les processus

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 

Et cela tue simplement le processus par la référence PID .... Dans mon cas, je veux arrêter le 6231 / nodejs donc j'exécute la commande suivante:

kill -9 6231

Voici une autre solution qui mélange les idées des réponses précédentes. Il adopte l'approche du «processus d'élimination» tout en répondant aux préoccupations concernant l'indépendance de la plate-forme.

Il s'appuie sur le package tree-kill pour gérer la destruction de l'arborescence des processus du serveur. J'ai trouvé nécessaire de tuer tout l'arborescence des processus dans mes projets car certains outils (par exemple babel-node) génèrent des processus enfants. Si vous n'avez besoin de tuer qu'un seul processus, vous pouvez remplacer tree-kill par la process.kill()méthode intégrée .

La solution suit (les deux premiers arguments à spawn()doivent être modifiés pour refléter la recette spécifique pour exécuter votre serveur):

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

Notez que cette solution détache le script de démarrage du serveur (ie npm startretournera immédiatement et ne bloquera pas tant que le serveur ne sera pas arrêté). Si vous préférez le comportement de blocage traditionnel, supprimez simplement l' options.detachedargument à spawn()et l'appel à child.unref().

Si vous avez déjà essayé ctrl + cet que cela ne fonctionne toujours pas, vous pouvez essayer ceci. Cela a fonctionné pour moi.

1. Exécutez la ligne de commande en tant qu'administrateur. Exécutez ensuite la commande ci-dessous pour trouver le processID (PID) que vous souhaitez supprimer. Tapez votre numéro de port dans<yourPortNumber>

   netstat -ano | findstr :<yourPortNumber>

2. Ensuite, vous exécutez cette commande après avoir identifié le PID.

   taskkill /PID <typeYourPIDhere> /F

Félicitations à @mit $ ingh de http://www.callstack.in/tech/blog/windows-kill-process-by-port-number-157

Si c'est très simple, il suffit de tuer le processus.

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

Pour Windows Machine (je suis sous Windows 10), si la commande CTRL + C (Annuler / Abandonner) sur cli ne fonctionne pas et que l'écran s'affiche comme ceci:

Essayez d'abord d'appuyer sur ENTRÉE (ou n'importe quelle touche le ferait), puis CTRL + C et le processus en cours vous demandera si vous souhaitez terminer le travail par lots:

Peut-être que CTRL + C termine uniquement le processus parent tandis que npm start s'exécute avec d'autres processus enfants. Je ne sais pas pourquoi vous devez appuyer sur cette touche supplémentaire avant CTRL + C, mais cela fonctionne mieux que de fermer la ligne de commande et de recommencer.

Un problème connexe que vous voudrez peut-être vérifier: https://github.com/mysticatea/npm-run-all/issues/74

Pour les environnements de production, vous devez utiliser Forever.js

C'est tellement utile pour le processus de démarrage et d'arrêt du nœud que vous pouvez également répertorier les applications en cours d'exécution.

https://github.com/foreverjs/forever

Vous pouvez utiliser pm2

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

après l'installation, tapez simplement le terminal

pm2 start app.js puis

pm2 stop 0 pour arrêter votre serveur

Dans le cas où votre fichier json n'a pas de script pour arrêter l'application, une option que j'utilise consiste simplement à appuyer sur ctrl + C sur la cmd.

Toute (3) solotion est:

1- ctlr + C

2- dans le fichier json, un script qui s'arrête

"scripts": {"stop": "killall -SIGINT ce-nom-peut-être-aussi-long-qu'il-doit-être"},

* que dans la commande write // npm stop //

3- Redémarrez le pc

Vous devez appuyer sur la combinaison ctrl + z Mon système d'exploitation est Ubuntu