如何运行节点。js应用作为后台服务?

Since this post has gotten a lot of attention over the years, I've listed the top solutions per platform at the bottom of this post.

由于这篇文章多年来受到了很多关注，我在这篇文章的底部列出了每个平台的最佳解决方案。

---

Original post:

原来的帖子:

I want my node.js server to run in the background, i.e.: when I close my terminal I want my server to keep running. I've googled this and came up with this tutorial, however it doesn't work as intended. So instead of using that daemon script, I thought I just used the output redirection (the 2>&1 >> file part), but this too does not exit - I get a blank line in my terminal, like it's waiting for output/errors.

我希望我的节点。在后台运行的js服务器，即。:当我关闭终端时，我希望我的服务器继续运行。我在google上搜索了这个，并找到了这个教程，但是它并没有达到预期的效果。因此，我没有使用这个守护进程脚本，我以为我只是使用了输出重定向(2>和1 >>文件部分)，但是这也没有退出——我的终端上有一条空行，就像它在等待输出/错误一样。

I've also tried to put the process in the background, but as soon as I close my terminal the process is killed as well.

我也尝试过将进程放在后台，但是一旦我关闭终端，进程也会被终止。

So how can I leave it running when I shut down my local computer?

那么，当我关闭本地电脑时，我怎么能让它继续运行呢?

---

Top solutions:

高级解决方案:

• Systemd (Linux)
• Systemd(Linux)
• Launchd (Mac)
• Launchd(Mac)
• node-windows (Windows)
• node-windows(Windows)
• PM2 (Node.js)
• PM2(node . js)

24 个解决方案

#1

Copying my own answer from How do I run a Node.js application as its own process?

从如何运行节点复制我自己的答案。js应用程序作为自己的进程?

2015 answer: nearly every Linux distro comes with systemd, which means forever, monit, etc are no longer necessary - your OS already handles these tasks.

2015年的答案:几乎每一个Linux发行版都有systemd，这意味着永远、monit等不再需要了——您的操作系统已经处理了这些任务。

Make a myapp.service file (replacing 'myapp' with your app's name, obviously):

myapp。服务文件(显然是用你的应用的名字来替换‘myapp’):

[Unit]
Description=My app

[Service]
ExecStart=/var/www/myapp/app.js
Restart=always
User=nobody
# Note RHEL/Fedora uses 'nobody', Debian/Ubuntu uses 'nogroup'
Group=nobody  
Environment=PATH=/usr/bin:/usr/local/bin
Environment=NODE_ENV=production
WorkingDirectory=/var/www/myapp

[Install]
WantedBy=multi-user.target

Note if you're new to Unix: /var/www/myapp/app.js should have #!/usr/bin/env node on the very first line.

注意，如果您是Unix新手，请注意:js应该# !第一行的/usr/bin/env节点。

Copy your service file into the /etc/systemd/system.

将您的服务文件复制到/etc/ systemd/system.com。

Start it with systemctl start myapp.

从systemctl Start myapp开始。

Enable it to run on boot with systemctl enable myapp.

使它在systemctl Enable myapp引导下运行。

See logs with journalctl -u myapp

使用journalctl - myu应用程序查看日志

This is taken from How we deploy node apps on Linux, 2018 edition, which also includes commands to generate an AWS/DigitalOcean/Azure CloudConfig to build Linux/node servers (including the .service file).

这是我们在Linux 2018版上部署节点应用程序的方式，它还包含生成AWS/DigitalOcean/Azure CloudConfig的命令，用于构建Linux/节点服务器(包括.service文件)。

#2

You can use Forever, A simple CLI tool for ensuring that a given node script runs continuously (i.e. forever): https://www.npmjs.org/package/forever

您可以使用一个简单的CLI工具Forever来确保给定的节点脚本持续运行(即永久运行):https://www.npmjs.org/package/forever

#3

UPDATE - As mentioned in one of the answers below, PM2 has some really nice functionality missing from forever. Consider using it.

更新-正如下面的一个答案所提到的，PM2有一些非常好的功能，这是永久缺失的。考虑使用它。

Original Answer

原来的答案

Use nohup:

使用nohup:

nohup node server.js &

EDIT I wanted to add that the accepted answer is really the way to go. I'm using forever on instances that need to stay up. I like to do npm install -g forever so it's in the node path and then just do forever start server.js

编辑我想补充的是，公认的答案是真正的出路。我在需要熬夜的情况下使用forever。我喜欢做npm，永远安装-g，这样它就在节点路径中，然后永远启动server.js。

#4

2016 Update: The node-windows/mac/linux series uses a common API across all operating systems, so it is absolutely a relevant solution. However; node-linux generates systemv init files. As systemd continues to grow in popularity, it is realistically a better option on Linux. PR's welcome if anyone wants to add systemd support to node-linux :-)

2016年更新:node-windows/mac/linux系列在所有操作系统中都使用一个通用的API，因此它绝对是一个相关的解决方案。然而;node-linux生成systemv init文件。随着systemd越来越受欢迎，它实际上是Linux上更好的选择。如果有人想为node-linux添加systemd支持，欢迎PR:-)

Original Thread:

原始线程:

This is a pretty old thread now, but node-windows provides another way to create background services on Windows. It is loosely based on the nssm concept of using an exe wrapper around your node script. However; it uses winsw.exe instead and provides a configurable node wrapper for more granular control over how the process starts/stops on failures. These processes are available like any other service:

这是一个非常古老的线程，但node-windows提供了另一种方法来在Windows上创建后台服务。它松散地基于nssm概念，即在您的节点脚本周围使用exe包装器。然而;它使用winsw。相反，它提供了一个可配置的节点包装器，用于更细粒度地控制进程如何启动/停止故障。这些流程与其他任何服务一样:

The module also bakes in some event logging:

该模块也在一些事件日志中出现:

Daemonizing your script is accomplished through code. For example:

通过代码实现对脚本的虚拟化。例如:

var Service = require('node-windows').Service;

// Create a new service object
var svc = new Service({
  name:'Hello World',
  description: 'The nodejs.org example web server.',
  script: 'C:\\path\\to\\my\\node\\script.js'
});

// Listen for the "install" event, which indicates the
// process is available as a service.
svc.on('install',function(){
  svc.start();
});

// Listen for the "start" event and let us know when the
// process has actually started working.
svc.on('start',function(){
  console.log(svc.name+' started!\nVisit http://127.0.0.1:3000 to see it in action.');
});

// Install the script as a service.
svc.install();

The module supports things like capping restarts (so bad scripts don't hose your server) and growing time intervals between restarts.

该模块支持诸如限制重新启动(因此糟糕的脚本不会占用服务器)和重新启动之间的增长时间间隔。

Since node-windows services run like any other, it is possible to manage/monitor the service with whatever software you already use.

由于node-windows服务像其他任何服务一样运行，因此可以使用您已经使用的任何软件来管理/监视服务。

Finally, there are no make dependencies. In other words, a straightforward npm install -g node-windows will work. You don't need Visual Studio, .NET, or node-gyp magic to install this. Also, it's MIT and BSD licensed.

最后，没有依赖项。换句话说，一个简单的npm安装-g节点窗口将有效。您不需要Visual Studio、. net或node-gyp魔法来安装它。此外，它是MIT和BSD许可的。

In full disclosure, I'm the author of this module. It was designed to relieve the exact pain the OP experienced, but with tighter integration into the functionality the Operating System already provides. I hope future viewers with this same question find it useful.

在全面披露中，我是这个模块的作者。它的设计初衷是为了减轻OP所经历的痛苦，但更紧密地集成到操作系统已经提供的功能中。我希望将来有同样问题的观众会觉得它有用。

#5

This might not be the accepted way, but I do it with screen, especially while in development because I can bring it back up and fool with it if necessary.

这可能不是一种被接受的方式，但我用屏幕来做，特别是在开发过程中，因为如果需要的话，我可以把它拿回来，然后用它蒙混过关。

screen
node myserver.js
>>CTRL-A then hit D

The screen will detach and survive you logging off. Then you can get it back back doing screen -r. Hit up the screen manual for more details. You can name the screens and whatnot if you like.

当你退出时，屏幕将会分离，并在你退出后继续运行。点击屏幕手册了解更多细节。如果你喜欢，你可以给屏幕命名。

#6

UPDATE: i updated to include the latest from pm2:

更新:我更新了最新的pm2:

for many use cases, using a systemd service is the simplest and most appropriate way to manage a node process. for those that are running numerous node processes or independently-running node microservices in a single environment, pm2 is a more full featured tool.

对于许多用例，使用systemd服务是管理节点进程的最简单和最合适的方式。对于那些在单个环境中运行大量节点进程或独立运行节点微服务的人来说，pm2是一种功能更丰富的工具。

https://github.com/unitech/pm2

https://github.com/unitech/pm2

http://pm2.io

http://pm2.io

• it has a really useful monitoring feature -> pretty 'gui' for command line monitoring of multiple processes with pm2 monit or process list with pm2 list
• 它有一个非常有用的监视特性——>漂亮的“gui”，用于使用pm2 monit对多个进程进行命令行监视，或者使用pm2列表对进程列表进行监视
• organized Log management -> pm2 logs
• 组织日志管理-> pm2日志。
• other stuff:

  • Behavior configuration
  • 行为的配置
  • Source map support
  • 源映射支持
  • PaaS Compatible
  • PaaS兼容
  • Watch & Reload
  • 手表和重载
  • Module System
  • 模块系统
  • Max memory reload
  • 最大内存重新加载
  • Cluster Mode
  • 集群模式
  • Hot reload
  • 热重载
  • Development workflow
  • 开发工作流程
  • Startup Scripts
  • 启动脚本
  • Auto completion
  • 自动完成
  • Deployment workflow
  • 部署工作流程
  • Keymetrics monitoring
  • Keymetrics监控
  • API
  • API

• 其他功能:行为配置源映射支持PaaS兼容的Watch & Reload模块系统最大内存重载集群模式热重载开发工作流程启动脚本自动完成部署工作流程关键指标监控API

#7

If you are running OSX, then the easiest way to produce a true system process is to use launchd to launch it.

如果您正在运行OSX，那么生成真正的系统进程的最简单方法就是使用launchd启动它。

Build a plist like this, and put it into the /Library/LaunchDaemons with the name top-level-domain.your-domain.application.plist (you need to be root when placing it):

构建一个这样的plist，并将其放入/Library/ launchdaemon名称为top-level-domain.your-domain.application。plist(放置时必须是根):

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>top-level-domain.your-domain.application</string>

    <key>WorkingDirectory</key>
    <string>/your/preferred/workingdirectory</string>

    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/node</string>
        <string>your-script-file</string>
    </array>

    <key>RunAtLoad</key>
    <true/>

    <key>KeepAlive</key>
    <true/>

</dict>
</plist>

When done, issue this (as root):

当完成时，发出这个(作为根):

launchctl load /Library/LaunchDaemons/top-level-domain.your-domain.application.plist
launchctl start top-level-domain.your-domain.application

and you are running.

你正在运行。

And you will still be running after a restart.

在重新启动之后，您仍将继续运行。

For other options in the plist look at the man page here: https://developer.apple.com/library/mac/documentation/Darwin/Reference/Manpages/man5/launchd.plist.5.html

关于plist中的其他选项，请查看这里的man页面:https://developer.apple.com/library/mac/documentation/darwination/reference/manpages/man5/launchd.plist.html

#8

I am simply using the daemon npm module:

我只是在使用守护进程npm模块:

var daemon = require('daemon');

daemon.daemonize({
    stdout: './log.log'
  , stderr: './log.error.log'
  }
, './node.pid'
, function (err, pid) {
  if (err) {
    console.log('Error starting daemon: \n', err);
    return process.exit(-1);
  }
  console.log('Daemonized successfully with pid: ' + pid);

  // Your Application Code goes here
});

Lately I'm also using mon(1) from TJ Holowaychuk to start and manage simple node apps.

最近我还在使用TJ Holowaychuk的mon(1)来启动和管理简单的节点应用程序。

#9

I use Supervisor for development. It just works. When ever you make changes to a .js file Supervisor automatically restarts your app with those changes loaded.

我使用主管进行开发。它只是工作。当您对.js文件管理器进行更改时，会自动重新启动应用程序，并加载这些更改。

Here's a link to its Github page

这里有一个Github页面的链接

Install :

安装:

sudo npm install supervisor -g

安装管理程序-g

You can easily make it watch other extensions with -e. Another command I use often is -i to ignore certain folders.

你可以很容易地让它看其他扩展与-e。我经常使用的另一个命令是-i忽略某些文件夹。

You can use nohup and supervisor to make your node app run in the background even after you log out.

您可以使用nohup和supervisor使您的节点应用程序在后台运行，甚至在您注销之后。

sudo nohup supervisor myapp.js &

sudo nohup主管myapp。js &

#10

Node.js as a background service in WINDOWS XP

节点。js作为WINDOWS XP的后台服务。

• Kudos goes to Hacksparrow at: http://www.hacksparrow.com/install-node-js-and-npm-on-windows.html for tutorial installing Node.js + npm for windows.
• 请访问Hacksparrow: http://www.hacksparrow.com/install-node- and-npm-on-windows.html，以了解如何安装节点。用于windows的js + npm。
• Kudos goes to Tatham Oddie at: http://blog.tatham.oddie.com.au/2011/03/16/node-js-on-windows/ for nnsm.exe implementation.
• Kudos去了Tatham Oddie: http://blog.tatham.oddie.com.au/2011/03/16/ nodejs-windows/为nnsm。exe实现。

Installation:

安装:

1. Install WGET http://gnuwin32.sourceforge.net/packages/wget.htm via installer executable
2. 通过安装程序可执行文件安装WGET http://gnuwin32.sourceforge.net/packages/wget.htm
3. Install GIT http://code.google.com/p/msysgit/downloads/list via installer executable
4. 通过安装程序可执行文件安装GIT http://code.google.com/p/msysgit/downloads/list
5. Install NSSM http://nssm.cc/download/?page=download via copying nnsm.exe into %windir%/system32 folder
6. NSSM http://nssm.cc/download/?安装通过复制nnsm页面=下载。exe到%列出% / system32系统文件夹

7. Create c:\node\helloworld.js

   创建c:\ \ helloworld.js节点

   // http://howtonode.org/hello-node
   var http = require('http');
   var server = http.createServer(function (request, response) {
       response.writeHead(200, {"Content-Type": "text/plain"});
       response.end("Hello World\n");
   });
   server.listen(8000);
   console.log("Server running at http://127.0.0.1:8000/");
   

8. Open command console and type the following (setx only if Resource Kit is installed)

   打开命令控制台并输入以下命令(只有在安装了资源包时才设置setx)

   C:\node> set path=%PATH%;%CD%
   C:\node> setx path "%PATH%"
   C:\node> set NODE_PATH="C:\Program Files\nodejs\node_modules"
   C:\node> git config --system http.sslcainfo /bin/curl-ca-bundle.crt    
   C:\node> git clone --recursive git://github.com/isaacs/npm.git    
   C:\node> cd npm    
   C:\node\npm> node cli.js install npm -gf   
   C:\node> cd ..    
   C:\node> nssm.exe install node-helloworld "C:\Program Files\nodejs\node.exe" c:\node\helloworld.js    
   C:\node> net start node-helloworld
   

9. A nifty batch goodie is to create c:\node\ServiceMe.cmd

   一个漂亮的批处理好是创建c:\node\ServiceMe.cmd。

   @echo off
   nssm.exe install node-%~n1 "C:\Program Files\nodejs\node.exe" %~s1
   net start node-%~n1
   pause
   

Service Management:

服务管理:

• The services themselves are now accessible via Start-> Run-> services.msc or via Start->Run-> MSCONFIG-> Services (and check 'Hide All Microsoft Services').
• 服务本身现在可以通过Start-> Run->服务访问。msc或通过启动->运行-> MSCONFIG->服务(并检查“隐藏所有微软服务”)。
• The script will prefix every node made via the batch script with 'node-'.
• 该脚本将用“node-”对通过批处理脚本生成的每个节点进行前缀。
• Likewise they can be found in the registry: "HKLM\SYSTEM\CurrentControlSet\Services\node-xxxx"
• 同样，它们也可以在注册表中找到:“HKLM\SYSTEM\CurrentControlSet\Services\node-xxxx”

#11

If you simply want to run the script uninterrupted until it completes you can use nohop as already mentioned in the answers here. However, none of the answers provide a full command that also logs stdin and stdout.

如果您只想不间断地运行脚本，直到它完成，您可以使用nohop，正如这里的答案中已经提到的。但是，没有一个答案提供完整的命令来记录stdin和stdout。

nohup node index.js >> app.log 2>&1 &

• The >> means append to app.log.
• >>表示追加到app.log。
• 2>&1 makes sure that errors are also send to stdout and added to the app.log.
• >&1确保错误也被发送到stdout并添加到app.log。
• The ending & makes sure your current terminal is disconnected from command so you can continue working.
• 结尾&确保当前终端与命令断开连接，以便继续工作。

If you want to run a node server (or something that should start back up when the server restarts) you should use systemd / systemctl.

如果您想运行一个节点服务器(或者当服务器重新启动时应该启动的东西)，您应该使用systemd / systemctl。

#12

The accepted answer is probably the best production answer, but for a quick hack doing dev work, I found this:

公认的答案可能是最佳的生产答案，但是对于快速破解开发工作，我发现:

nodejs scriptname.js & didn't work, because nodejs seemed to gobble up the &, and so the thing didn't let me keep using the terminal without scriptname.js dying.

nodejs scriptname。js &没有工作，因为nodejs似乎在吞掉&，所以这个东西没有让我继续使用终端，没有scriptname。js死亡。

But I put nodejs scriptname.js in a .sh file, and nohup sh startscriptname.sh & worked.

但是我写了nodejs scriptname。在一个。sh文件中，nohup sh startscriptname。sh &工作。

Definitely not a production thing, but it solves the "I need to keep using my terminal and don't want to start 5 different terminals" problem.

肯定不是一个生产产品，但它解决了“我需要继续使用我的终端，不想启动5个不同的终端”的问题。

#13

If you are running nodejs in linux server, I think this is the best way.

如果您正在linux服务器上运行nodejs，我认为这是最好的方法。

Create a service script and copy to /etc/init/nodejs.conf

创建一个服务脚本并将其复制到/etc/init/nodejs.conf

start service: sudo service nodejs start

启动服务:sudo服务nodejs启动

stop service: sudo service nodejs stop

停止服务:sudo服务nodejs停止。

Sevice script

服务脚本

description "DManager node.js server - Last Update: 2012-08-06"
author      "Pedro Muniz - [e-mail]"

env USER="nodejs" #you have to create this user 
env APPNAME="nodejs" #you can change the service name
env WORKDIR="/home/<project-home-dir>" #set your project home folder here
env COMMAND="/usr/bin/node <server name>" #app.js ?

# used to be: start on startup
# until we found some mounts weren't ready yet while booting:
start on started mountall
stop on shutdown

# Automatically Respawn:
respawn
respawn limit 99 5

pre-start script
    sudo -u $USER echo "[`date -u +%Y-%m-%dT%T.%3NZ`] (sys) Starting" >> /var/log/$APPNAME.log
end script

script
    # Not sure why $HOME is needed, but we found that it is:
    export HOME="<project-home-dir>"  #set your project home folder here
    export NODE_PATH="<project node_path>"

    #log file, grant permission to nodejs user
    exec start-stop-daemon --start --make-pidfile --pidfile /var/run/$APPNAME.pid --chuid $USER --chdir $WORKDIR --exec $COMMAND >> /var/log/$APPNAME.log 2>&1
end script

post-start script
   # Optionally put a script here that will notifiy you node has (re)started
   # /root/bin/hoptoad.sh "node.js has started!"
end script

pre-stop script
    sudo -u $USER echo "[`date -u +%Y-%m-%dT%T.%3NZ`] (sys) Stopping" >> /var/log/$APPNAME.log
end script

#14

Try to run this command if you are using nohup -

如果您正在使用nohup -，请尝试运行此命令

nohup npm start 2>/dev/null 1>/dev/null&

You can also use forever to start server

您还可以使用forever来启动服务器

forever start -c "npm start" ./ 

#15

To round out the various options suggested, here is one more: the daemon command in GNU/Linux, which you can read about here: http://libslack.org/daemon/manpages/daemon.1.html. (apologies if this is already mentioned in one of the comments above).

要完善所建议的各种选项，这里还有一个:GNU/Linux中的守护程序命令，您可以在这里阅读:http://libslack.org/daemon/manpages/daemon.1.html。(如果上面的评论中已经提到这一点，请表示歉意)。

#16

use nssm the best solution for windows, just download nssm, open cmd to nssm directory and type

使用nssm是windows的最佳解决方案，只需下载nssm，打开cmd到nssm目录并输入

nssm install <service name> <node path> <app.js path> 

eg: nssm install myservice "C:\Program Files\nodejs" "C:\myapp\app.js" 

this will install a new windows service which will be listed at services.msc from there you can start or stop the service, this service will auto start and you can configure to restart if it fails.

这将安装一个新的windows服务，该服务将在services中列出。从这里开始，您可以启动或停止服务，该服务将自动启动，如果失败，您可以配置为重新启动。

#17

June 2017 Update:
Solution for Linux: (Red hat). Previous comments doesn't work for me. This works for me on Amazon Web Service - Red Hat 7. Hope this works for somebody out there.

2017年6月更新:Linux解决方案:(Red hat)。以前的评论对我不起作用。这对我在亚马逊网络服务——红帽7上是有效的。希望这对外面的人有用。

A. Create the service file 
sudo vi /etc/systemd/system/myapp.service
[Unit]
Description=Your app
After=network.target

[Service]
ExecStart=/home/ec2-user/meantodos/start.sh
WorkingDirectory=/home/ec2-user/meantodos/

[Install]
WantedBy=multi-user.target

---

B. Create a shell file
/home/ec2-root/meantodos/start.sh
#!/bin/sh -
sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to 8080
npm start

then:
chmod +rx /home/ec2-root/meantodos/start.sh
(to make this file executable)

---

C. Execute the Following

sudo systemctl daemon-reload
sudo systemctl start myapp
sudo systemctl status myapp

(If there are no errors, execute below.  Autorun after server restarted.)
chkconfig myapp -add

#18

Check out fugue! Apart from launching many workers, you can demonize your node process too!

看看神游!除了启动许多工作程序之外，您还可以妖魔化您的节点进程!

http://github.com/pgte/fugue

http://github.com/pgte/fugue

#19

PM2 is a production process manager for Node.js applications with a built-in load balancer. It allows you to keep applications alive forever, to reload them without downtime and to facilitate common system admin tasks. https://github.com/Unitech/pm2

PM2是Node的一个生产过程管理器。带有内置负载均衡器的js应用程序。它使您能够使应用程序永远处于活动状态，能够在不停机的情况下重新加载它们，并促进常见的系统管理任务。https://github.com/Unitech/pm2

#20

I am surprised that nobody has mentioned Guvnor

我很惊讶没有人提到Guvnor

I have tried forever, pm2, etc. But, when it comes to solid control and web based performance metrics, I have found Guvnor to be by far the best. Plus, it is also fully opensource.

我已经尝试了很久，pm2等等。但是，当涉及到可靠的控制和基于web的性能度量时，我发现Guvnor是目前为止最好的。另外，它也是完全开源的。

Edit : However, I am not sure if it works on windows. I've only used it on linux.

编辑:但是，我不确定它是否适用于windows。我只在linux上用过。

#21

has anyone noticed a trivial mistaken of the position of "2>&1" ?

有人注意到“2>和1”的位置有一个小错误吗?

2>&1 >> file

should be

应该是

>> file 2>&1

#22

I use tmux for a multiple window/pane development environment on remote hosts. It's really simple to detach and keep the process running in the background. Have a look at tmux

我将tmux用于远程主机上的多个窗口/窗格开发环境。分离和保持进程在后台运行非常简单。看看tmux

#23

This answer is quite late to the party, but I found that the best solution was to write a shell script that used the both the screen -dmS and nohup commands.

这个答案已经很晚了，但是我发现最好的解决方案是编写一个shell脚本，它使用了屏幕-dmS和nohup命令。

screen -dmS newScreenName nohup node myserver.js >> logfile.log

I also add the >> logfile bit on the end so I can easily save the node console.log() statements.

我还在末尾添加了>> logfile位，以便可以轻松保存node console.log()语句。

Why did I use a shell script? Well I also added in an if statement that checked to see if the node myserver.js process was already running.

为什么我要使用shell脚本?我还添加了if语句来检查mynode服务器。js进程已经在运行。

That way I was able to create a single command line option that both lets me keep the server going and also restart it when I have made changes, which is very helpful for development.

这样，我就可以创建一个命令行选项，既可以让服务器继续运行，也可以在进行更改时重新启动它，这对开发非常有帮助。

#24

Its very simple.

它非常简单。

1. Add package.json in your project
2. 添加包。json在您的项目中
3. Add script file name or path in your Package.JSON Start
4. 在包中添加脚本文件名或路径。JSON开始
5. Then simple go to your console open your project directory by cd path/to/directory/
6. 然后简单地转到控制台，按cd路径/到/目录/打开项目目录
7. Write nohup npm start
8. 写nohup npm开始

Following is a Package.JSON sample that anyone can use. { "name": "Project",

下面是一个包。任何人都可以使用的JSON示例。{ " name ":“项目”,

  "version": "1.0.0",

  "main": "httpsserver.js",

  "scripts": {

    "start": "node httpsserver.js"
  },

  "keywords": [],

  "author": "",

  "license": "ISC",

  "dependencies": {},

  "devDependencies": {},

  "description": ""

}