What is Express.js?

Express.js, commonly known as Express, is a minimalist and flexible web application framework for Node.js. It provides a robust set of features for web and mobile applications, allowing developers to build single-page, multi-page, and hybrid web applications with ease.

Why Use Express.js?

Simplicity and Minimalism: Express has a simple interface that provides just enough features without being overly complex. It allows developers to build applications quickly without unnecessary overhead.
Performance: As a framework built on top of Node.js, Express benefits from Node's high performance, particularly its non-blocking, asynchronous nature.
Routing: Express offers a powerful and flexible routing system, which is fundamental for managing different endpoints in a web application.
Community and Ecosystem: Express has a large and active community. This means plenty of available resources, tutorials, and plugins to extend its functionality.

Getting Started with Express.js

Installation

Before installing Express, ensure you have Node.js and npm (Node Package Manager) installed. You can download Node.js from the official website.

To install Express, use the following command:

npm install express --save

Creating a Simple Express Application

Initialize a Project: Create a new directory for your project and initialize a Node.js project.
```
mkdir my-express-app
cd my-express-app
npm init -y
```
Install Express: Install Express in your project directory.
```
npm install express --save
```

Create the Application: Create a file named app.js and add the following code to set up a basic Express server.

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

app.get('/', (req, res) => {
    res.send('Hello, World!');
});

app.listen(port, () => {
    console.log(`App is listening at http://localhost:${port}`);
});

Run the Application: Start your Express server by running the following command:
```
node app.js
```
Navigate to http://localhost:3000 in your web browser. You should see the message "Hello, World!".

Key Features of Express.js

1.Routing

Express provides a robust routing system that allows you to define application routes based on HTTP methods and URLs. Routing is essential for handling different operations and functionalities within an application.

Example of defining routes:

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

app.get('/', (req, res) => {
    res.send('Home Page');
});

app.get('/about', (req, res) => {
    res.send('About Page');
});

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

In the example above:

app.get('/') defines a route for the home page.
app.get('/about') defines a route for the about page.

2.Handling Requests and Responses

Express simplifies the process of handling HTTP requests and responses. The req (request) object represents the HTTP request and contains properties for the request query string, parameters, body, HTTP headers, and more. The res (response) object represents the HTTP response that an Express app sends when it gets an HTTP request.

Example of handling POST requests:

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

// Middleware to parse JSON bodies
app.use(express.json());

app.post('/submit', (req, res) => {
    const data = req.body;
    res.send(`Received data: ${JSON.stringify(data)}`);
});

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

3.Template Engines

Express supports various template engines to generate dynamic HTML. Template engines allow you to use static template files in your application. At runtime, the template engine replaces variables in a template file with actual values and transforms the template into an HTML file sent to the client.

Example of using Pug (formerly Jade):

Install Pug:
```
npm install pug --save
```

Setup Pug in Express:

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

app.set('view engine', 'pug');
app.set('views', './views');

app.get('/', (req, res) => {
    res.render('index', { title: 'Express', message: 'Hello, Pug!' });
});

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

Create a Pug Template:

Create a file named index.pug in the views directory with the following content:

doctype html
html
    head
        title= title
    body
        h1= message

When you navigate to the home route, Express will render the Pug template and send the generated HTML to the client.

4.Error Handling

Express provides a straightforward way to handle errors. Error-handling middleware functions are functions that have four arguments: err, req, res, and next.

Example of error handling middleware:

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

app.get('/', (req, res) => {
    throw new Error('Something went wrong!');
});

// Error handling middleware
app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send('Something broke!');
});

app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

In this example, when an error is thrown in the route handler, it is caught by the error-handling middleware, which logs the error stack and sends a 500 status response to the client.

Conclusion

Express.js is a powerful, flexible, and minimalistic framework for building web applications in Node.js. It provides essential features like routing, template engines, and error handling, while leveraging the high performance and non-blocking nature of Node.js. With its extensive community support and wide array of plugins and extensions, Express.js simplifies the development process, enabling developers to create robust and scalable web applications efficiently. Whether you're working on simple web pages or complex web applications, Express.js offers the tools and features you need to get the job done.

PreviousDeepdown with Packages & Filesystem NextWhat is Middleware?