How to Restart Your node.JS Apps Automatically With Nodemon
Tags: tutorials
Published: 2021-12-07 18:40:06

---
title: How to Restart Your node.JS Apps Automatically With Nodemon
published: true
date: 2021-11-27 10:36:22 UTC
tags: Tutorials
canonical_url: https://stackallflow.com/tutorials/how-to-restart-your-node-js-apps-automatically-with-nodemon/
---

### Introduction

In Node.js, you need to restart the process to make changes take effect. This adds an extra step to your workflow. You can eliminate this extra step by using [`nodemon`](https://nodemon.io/) to restart the process automatically.

`nodemon` is a command-line interface (CLI) utility developed by [@rem](https://twitter.com/rem) that wraps your Node app, watches the file system, and automatically restarts the process.

In this article, you will learn about installing, setting up, and configuring `nodemon`.

## Prerequisites

If you would like to follow along with this article, you will need:

- Node.js installed locally, which you can do by following [How to Install Node.js and Create a Local Development Environment](https://www.digitalocean.com/community/tutorial_series/how-to-install-node-js-and-create-a-local-development-environment).

This tutorial was verified with Node.js v17.1.0, npm v8.1.2, `nodemon` v2.0.15, and `express` v4.17.1.

## Step 1 — Installing `nodemon`

First, you will need to install `nodemon` on your machine. Install the utility either globally or locally on your project using [`npm` or `yarn`](https://www.digitalocean.com/community/tutorials/nodejs-adding-removing-packages-npm-yarn):

### Global Installation

You can install `nodemon` globally with `npm`:



- npm install nodemon –global



Or with `yarn`:



- yarn global add nodemon



### Local Installation

You can also install `nodemon` locally. When performing a local installation, you can install `nodemon` as a [dev dependency](https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file) with `--save-dev` (or `--dev`).

Install `nodemon` locally with `npm`:



- npm install nodemon –save-dev



Or with `yarn`:



- yarn add nodemon –dev



One thing to be aware of with a local install is that you will not be able to use the `nodemon` command directly:



Output



- command not found: nodemon



You can execute the locally installed package:



- ./node\_modules/nodemon/bin/nodemon.js [your node app]



You can also use it in [npm scripts](https://www.digitalocean.com/community/tutorials/nodejs-utilizing-npm-scripts-during-development) or with [npx](https://www.digitalocean.com/community/tutorials/workflow-npx).

This concludes the `nodemon` installation process.

## Step 2 — Setting Up an Example Express Project with `nodemon`

You can use `nodemon` to start a Node script. For example, if you have an [Express server setup](https://www.digitalocean.com/community/tutorials/nodejs-express-basics) in a `server.js` file, you can start `nodemon` and watch for changes like this:



- nodemon server.js



You can pass in arguments the same way as if you were running the script with Node:



- nodemon server.js 3006



Every time you make a change to a file with one of the default watched extensions (`.js`, `.mjs`, `.json`, `.coffee`, or `.litcoffee`) in the current directory or a subdirectory, the process will restart.

Let’s write an example `server.js` file that outputs the message: `Dolphin app listening on port ${port}!`.

server.js

```
const express = require('express')
const app = express()
const port = 3000

app.listen(port, ()=> console.log(`Dolphin app listening on port ${port}!`))

```

Run the example with `nodemon`:



- nodemon server.js



The terminal output will display:



Output

```
[nodemon] 2.0.15
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,json
[nodemon] starting `node server.js`
Dolphin app listening on port 3000!

```

While `nodemon` is still running, let’s make a change to the `server.js` file. Change the output a different message: `Shark app listening on port ${port}!`.

The terminal output will display:



Output

```
[nodemon] restarting due to changes...
[nodemon] starting `node server.js`
Shark app listening on port 3000!

```

The terminal output from the Node.js app is displaying the new changes.

You can restart the process at any time by typing `rs` and hitting `ENTER`.

Alternatively, `nodemon` will also look for a `main` file specified in your project’s `package.json` file:

package.json

```
{
  // ...
  "main": "server.js",
  // ...
}

```

If a `main` file is not specified, `nodemon` will search for a `start` script:

package.json

```
{
  // ...
  "scripts": {
    "start": "node server.js"
  },
  // ...
}

```

Once you make the changes to `package.json`, you can then call `nodemon` to start the example app in watch mode without having to pass in `server.js`.

## Step 3 — Using Options

You can modify the configuration settings available to `nodemon`.

Let’s go over some of the main options:

- `--exec`: Use the `--exec` switch to specify a binary to execute the file with. For example, when combined with the [`ts-node`](https://github.com/TypeStrong/ts-node) binary, `--exec` can become useful to watch for changes and run TypeScript files.
- `--ext`: Specify different file extensions to watch. For this switch, provide a comma-separated list of file extensions (e.g., `--ext js,ts`).
- `--delay`: By default, `nodemon` waits for one second to restart the process when a file changes, but with the `--delay` switch, you can specify a different delay. For example, `nodemon --delay 3.2` for a 3.2-second delay.
- `--watch`: Use the `--watch` switch to specify multiple directories or files to watch. Add one `--watch` switch for each directory you want to watch. By default, the current directory and its subdirectories are watched, so with `--watch` you can narrow that to only specific subdirectories or files.
- `--ignore`: Use the `--ignore` switch to ignore certain files, file patterns, or directories.
- `--verbose`: A more verbose output with information about what file(s) changed to trigger a restart.

You can view all the available options with the following command:



- nodemon –help



Using these options, let’s create the command to satisfy the following scenario:

- watching the `server` directory
- specifying files with a `.ts` extension
- ignoring files with a `.test.ts` suffix
- executing the file (`server/server.ts`) with `ts-node`
- waiting for three seconds to restart after a file changes



- nodemon –watch server –ext ts –exec ts-node –ignore ‘\*.test.ts’ –delay 3 server/server.ts



The terminal output will display:



Output

```
[nodemon] 2.0.15
[nodemon] to restart at any time, enter `rs`
[nodemon] watching path(s): server
[nodemon] watching extensions: ts
[nodemon] starting `ts-node server/server.ts`

```

This command combines `--watch`, `--ext`, `--exec`, `--ignore`, and `--delay` options to satisfy the conditions for our scenario.

## Step 4 — Using Configurations

In the previous example, adding configuration switches when running `nodemon` can get tedious. A better solution for projects that require complicated configurations is to define these options in a `nodemon.json` file.

For example, here are the same configurations as the previous command line example, but placed in a `nodemon.json` file:

nodemon.json

```
{
  "watch": [
    "server"
  ],
  "ext": "ts",
  "ignore": [
    "*.test.ts"
  ],
  "delay": "3",
  "execMap": {
    "ts": "ts-node"
  }
}

```

Note the use of `execMap` instead of the `--exec` switch. `execMap` allows you to specify binaries for certain file extensions.

Alternatively, if you would rather not add a `nodemon.json` config file to your project, you can add these configurations to the `package.json` file under a `nodemonConfig` key:

package.json

```
{
  "name": "nodemon-example",
  "version": "1.0.0",
  "description": "",
  "nodemonConfig": {
    "watch": [
      "server"
    ],
    "ext": "ts",
    "ignore": [
      "*.test.ts"
    ],
    "delay": "3",
    "execMap": {
      "ts": "ts-node"
    }
  },
  // ...

```

Once you make the changes to either `nodemon.json` or `package.json`, you can then start `nodemon` with the desired script:



- nodemon server/server.ts



`nodemon` will pick up the configurations and use them. This way, your configurations can be saved, shared, and repeated to avoid copy-and-pasting or typing errors in the command line.

## Conclusion

In this article, you explored how to use `nodemon` with your Node.js applications. This tool helps automate the process of stopping and starting a Node server to view the changes.

For more information about the available features and troubleshooting errors, consult [the official documentation](https://github.com/remy/nodemon).

The post [How to Restart Your node.JS Apps Automatically With Nodemon](https://stackallflow.com/tutorials/how-to-restart-your-node-js-apps-automatically-with-nodemon/) appeared first on [Stack All Flow](https://stackallflow.com).