error listen eaddrinuse address already in use 8080 with code examples

Introduction:

When you try to launch a port on your local machine, you might get the "Error: listen EADDRINUSE address already in use" message. This error message is basically telling you that the port your application is trying to listen on is already being used by another process.

This guide will help you understand the EADDRINUSE error, why it occurs, and how to fix it in different environments. Additionally, you can find code examples in Node.js to help illustrate the concepts.

What is EADDRINUSE error in Node.js?

When you run Node.js code that listens to a specific port, it does so by binding to a TCP/IP socket. Similar to a telephone line, a TCP/IP socket is a channel of communication between two applications.

EADDRINUSE error occurs when you try to bind to a socket that is already in use by another application.

Why does the EADDRINUSE error happen?

The primary cause of this error is that another application is currently using the same port that you are trying to bind to. This can happen for various reasons like-

You have previously run your Node.js app and did not terminate the server correctly. The old process might still be running and holding the port.
Another application on your system might be using the same port.
Your Node.js application is not properly shutting down previously running servers. As a result, the port is still in use.

How to fix EADDRINUSE error?

There are several ways to fix the EADDRINUSE error. Here are some of the most common ones:

Change the listening port: If the currently bound port is taken by another application, you can simply change the port number in your Node.js code or external configuration to a different port that is not in use.

Example Code:

const PORT = 8081;
app.listen(PORT, () => {
  console.log(`Server started listening on port ${PORT}`);
});

Terminate the process that is using the port: You can use the following commands to terminate the process that is using the port.

Windows: netstat -aon | findstr :<port number> followed by taskkill /F /PID <pid number>
macOS/Linux: sudo lsof -i :<port number> followed by kill -9 <pid number>

Example Code:

const net = require('net');
const server = net.createServer();
const port = 8080;

server.on('error', (err) => {
  if (err.code === 'EADDRINUSE') {
    console.log(`Port ${port} is currently in use`);
  } else {
    console.log(err);
  }
});

server.listen(port, () => {
  console.log(`Server started listening on port ${port}`);
});

Shutting down previously running servers correctly: In some cases, you may have multiple instances of your application running in the background, making it difficult to locate the server holding the port. In this case, you need to make sure you shut down any previously running servers correctly before attempting to start a new one and bind to the same port.

Example Code:

const express = require('express');
const app = express();

const PORT = 8080;

const server = app.listen(PORT, () => {
  console.log(`Server started listening on port ${PORT}`);
});

// shutting down the server properly
process.on('SIGTERM', () => {
  server.close(() => {
    console.log('Server closed correctly');
    process.exit(0);
  });
});

Conclusion:

The EADDRINUSE error occurs when you try to bind to a port that is already in use. The error may happen due to many reasons, like previously running server holding the port and another application is running on the same port. To fix this error, either change the port number in your Node.js code or terminate the process that is using the port. Additionally, you must ensure that any previously running servers are shut down correctly before attempting to start a new one and bind to the same port.

I can give you more information on the topics we covered in the previous article.

EADDRINUSE error in depth:

As mentioned in the previous article, the EADDRINUSE error occurs when you try to bind to a port that is already in use by another application. It is important to note that this error is not specific to Node.js. It can occur in any application or programming language that uses sockets and assigns them to specific ports.

When you try to bind to a port that is already in use, the operating system sends back an error message to your application indicating that the port is already taken. This error message is mapped to the EADDRINUSE error code.

In Node.js, you can handle this error by listening to the 'error' event on the server object. When this event is triggered, you can check the error code to determine if it is the EADDRINUSE error and take appropriate action.

Changing the listening port is a common solution to this error. However, it is important to ensure that the new port you choose is not already in use before binding to it.

Terminating the process that is using the port is another solution to this error. By terminating the process, you free up the port, allowing your application to bind to it. However, you need to be careful when terminating processes as it can cause unintended consequences on your system.

Shutting down previously running servers correctly is the best practice to avoid this error in the first place. When you shut down your server, ensure that it releases any resources it has acquired, including the port it was listening on.

Handling Errors in Node.js:

Errors are a natural part of any software development process. In Node.js, you can handle errors using various techniques. Some of the most common techniques are-

Callbacks: In Node.js, it is common practice to use callbacks to handle errors. When an error occurs, you pass it as the first argument to the callback function. If there is no error, you pass null or undefined.

Example Code-

fs.readFile('/path/to/file', (err, data) => {
  if (err) {
    console.error(err);
  } else {
    console.log(data);
  }
});

Promises: Promises are a cleaner way to handle errors than callbacks. Instead of passing error and data as separate arguments, you return a Promise that resolves with the data or rejects with an error.

Example Code-

const readFile = promisify(fs.readFile);

readFile('/path/to/file')
  .then((data) => {
    console.log(data);
  })
  .catch((err) => {
    console.error(err);
  });

try-catch: You can use the try-catch block to handle synchronous errors in your Node.js application. When an error occurs in the try block, it is caught by the catch block, and you can handle it accordingly.

Example Code-

try {
  const data = fs.readFileSync('/path/to/file');
  console.log(data);
} catch (err) {
  console.error(err);
}

Conclusion:

Error handling is an important aspect of building robust applications in Node.js. While the EADDRINUSE error can be frustrating to deal with, there are several solutions to it. Additionally, by understanding different techniques to handle errors in Node.js, you can make your code more resilient and predictable.

error listen eaddrinuse address already in use 8080 with code examples

Popular questions

Tag

Abdelmonem Aly

Leave a Reply Cancel reply

Popular questions

Tag

Abdelmonem Aly

Leave a Reply Cancel reply

Related Posts