J'ai un simple serveur TCP qui écoute sur un port.

var net = require("net");

var server = net.createServer(function(socket) {
    socket.end("Hello!\n");
});

server.listen(7777);

Je le démarre avec node server.jspuis le ferme avec Ctrl + Z sur Mac. Lorsque j'essaye de l'exécuter à nouveau avec node server.jsj'obtiens ce message d'erreur:

node.js:201
        throw e; // process.nextTick error, or 'error' event on first tick
          ^
Error: listen EADDRINUSE
at errnoException (net.js:670:11)
at Array.0 (net.js:771:26)
at EventEmitter._tickCallback (node.js:192:41)

Suis-je en train de fermer le programme dans le mauvais sens? Comment puis-je empêcher que cela se produise?

Pour terminer le programme, vous devez utiliser Ctrl+ C. Si vous faites cela, il envoie SIGINT, ce qui permet au programme de se terminer correctement, sans se lier de tous les ports sur lesquels il écoute.

Voir aussi: https://superuser.com/a/262948/48624

Ctrl+ le Zsuspend, ce qui signifie qu'il peut toujours fonctionner.

Ctrl+ Cle tuera réellement.

vous pouvez également le tuer manuellement comme ceci:

ps aux | grep node

Trouvez l'ID de processus (deuxième à partir de la gauche):

kill -9 PROCESS_ID

Cela peut également fonctionner

killall node

Ou vous pouvez également faire tout cela en une seule ligne:

kill -9 $(ps aux | grep '\snode\s' | awk '{print $2}')

Vous pouvez remplacer le nœud à l'intérieur de '\ snode \ s' par tout autre nom de processus.

Reprenez et tuez le processus:

Ctrl+ le Zsuspend, ce qui signifie qu'il fonctionne toujours en tant que processus d'arrière-plan suspendu.

Vous êtes probablement maintenant à une invite de terminal ...

1. Donnez la commande fgpour reprendre le processus au premier plan.

2. tapez Ctrl+ Cpour le tuer correctement.

Alternativement, vous pouvez le tuer manuellement comme ceci:

( REMARQUE: les commandes suivantes peuvent nécessiter un root, tout sudo ...comme votre ami)

pkill -9 node

ou, si vous n'avez pas pkill, cela peut fonctionner:

killall node

ou peut-être ceci:

kill $(ps -e | grep node | awk '{print $1}')

parfois le processus listera son propre grep, auquel cas vous aurez besoin de:

kill $(ps -e | grep dmn | awk '{print $2}')

.

h / t @ruffin des commentaires sur la question elle-même. J'ai eu le même problème et son commentaire m'a aidé à le résoudre moi-même.

vous pouvez taper .exit pour quitter le noeud js REPL

Si vous exécutez Node.js de manière interactive (le REPL):

Ctrl+ Cvous ramènera à> invite puis tapez:

process.exit()

ou utilisez simplement Ctrl+ D.

$ sudo killall nodedans un autre terminal fonctionne sur mac , tout en killall nodene fonctionnant pas:

$ killall node
No matching processes belonging to you were found

sur Linux, essayez: pkill node

sur les fenêtres:

Taskkill /IM node.exe /F

ou

from subprocess import call

call(['taskkill', '/IM', 'node.exe', '/F'])

Bien que ce soit une réponse tardive, je l'ai trouvée dans les documents NodeJS :

L'événement «exit» est émis lorsque le REPL est quitté soit en recevant la .exitcommande en entrée, l'utilisateur appuyant <ctrl>-Cdeux fois pour signaler SIGINT, soit en appuyant <ctrl>-Dpour signaler «end» sur le flux d'entrée. Le rappel de l'écouteur est appelé sans aucun argument.

Donc, pour résumer, vous pouvez quitter en:

1. Taper .exitdans nodejs REPL.
2. Appuyez <ctrl>-Cdeux fois.
3. en appuyant sur <ctrl>-D.
4. process.exit(0)ce qui signifie une sortie naturelle de REPL. Si vous souhaitez renvoyer tout autre statut, vous pouvez renvoyer un nombre différent de zéro.
5. process.kill(process.pid) est le moyen de tuer en utilisant l'API nodejs depuis votre code ou depuis REPL.

J'ajoute cette réponse parce que pour de nombreux projets avec des déploiements de production, nous avons des scripts qui arrêtent ces processus afin que nous n'ayons pas à le faire.

Une façon propre de gérer vos processus Node Server consiste à utiliser le foreverpackage (à partir deNPM ).

Exemple:

Installer pour toujours

npm install forever -g

Exécuter le serveur de noeud

forever start -al ./logs/forever.log -ao ./logs/out.log -ae ./logs/err.log server.js

Résultat:

info: Forever processing file: server.js

Serveur de noeud d'arrêt

forever stop server.js

Résultat

info: Forever stopped process: uid command script forever pid id logfile uptime [0] sBSj "/usr/bin/nodejs/node" ~/path/to/your/project/server.js 23084 13176 ~/.forever/forever.log 0:0:0:0.247

Cela arrêtera proprement votre application serveur.

Si vous souhaitez arrêter votre serveur avec npm stopou quelque chose comme ça. Vous pouvez écrire le code qui tue votre processus serveur comme:

require('child_process').exec(`kill -9 ${pid}`)

Consultez ce lien pour les détails: https://gist.github.com/dominhhai/aa7f3314ad27e2c50fd5

J'ai rencontré un problème où plusieurs serveurs de nœuds sont en cours d'exécution et je veux simplement en tuer un et le redéployer à partir d'un script.

Remarque: Cet exemple est dans un shell bash sur Mac.

Pour ce faire, je m'assure de rendre mon nodeappel aussi précis que possible. Par exemple, plutôt que d'appeler à node server.jspartir du répertoire des applications, j'appellenode app_name_1/app/server.js

Ensuite, je peux le tuer en utilisant:

kill -9 $(ps aux | grep 'node\ app_name_1/app/server.js' | awk '{print $2}')

Cela ne tuera que le processus de nœud exécutant app_name_1 / app / server.js.

Si tu as couru node app_name_2/app/server.js ce processus de noeud continuera de s'exécuter.

Si vous décidez de les tuer tous, vous pouvez les utiliser killall nodecomme d'autres l'ont mentionné.

Réponse tardive mais sur Windows, ouvrir le gestionnaire de tâches avec CTRL + ALT + SUPPR puis tuer les processus Node.js résoudra cette erreur.

vous pouvez travailler la commande suivante pour être spécifique dans localalserver kill (ici: 8000)

http: // localhost: 8000 / kill PID (processId):

$:lsof -i tcp:8000

Il vous donnera les groupes de TCP suivants:

UTILISATEUR PID UTILISATEUR TYPE FD TAILLE / NOM DU NŒUD DE L'APPAREIL

noeud 21521 ubuntu 12u IPv6 345668 0t0 TCP *: 8000 (ÉCOUTER)

$:kill -9 21521

Il tuera processId correspondant à TCP *: 8000

Pour MacOS

1. Terminal ouvert

2. Exécutez le code ci-dessous et appuyez sur Entrée

    sudo kill $(sudo lsof -t -i:4200)

Vous pouvez utiliser l' unité de fusion pour obtenir ce que vous voulez faire.

Afin d'obtenir les identifiants de processus des tâches s'exécutant sur un port, vous pouvez faire:

fuser <<target_port>>/tcp

Disons que le port est 8888, la commande devient:

fuser 8888/tcp

Et pour tuer un processus qui s'exécute sur un port, ajoutez simplement -k switch.

fuser <<target_port>>/tcp -k

Exemple (le port est 8888):

fuser 8888/tcp -k

C'est tout! Il fermera l'écoute du processus sur le port. Je le fais généralement avant d'exécuter mon application serveur.

Mon cas d'utilisation: sur MacOS , exécutez / réexécutez plusieurs serveurs de nœuds sur différents ports à partir d'un script

exécuter :"cd $PATH1 && node server1.js & cd $PATH2 && node server2.js & ..."

stop1 :"kill -9 $(lsof -nP -i4TCP:$PORT1 | grep LISTEN | awk '{print $2}')"

stop2, stop3 ...

réexécuter :"stop1 & stop2 & ... & stopN ; run

pour plus d'informations sur la recherche d'un processus par un port: Qui écoute sur un port TCP donné sous Mac OS X?

Pour Windows, recherchez d'abord le PID avec votre numéro de port

netstat -ano | findStr "portNumber"

Après cela, tuez la tâche, assurez-vous que vous êtes à la racine de votre lecteur "c" Et la commande serataskkill /F /PID your pid

si vous utilisez VS Code et le nœud de sélection de terminal dans le menu déroulant de droite, puis faites Ctrl + C. Ensuite, cela fonctionnera

Appuyez sur y lorsque vous y êtes invité.

Merci