Express js Interview Questions and Answers Web Development

Since Express.js is a framework for Node.js, the basic requirement is to have Node.js installed on the system. The installation of Node.js can be done in many different ways, depending on the operating system. The best way is to go to the Node.js official site https://Node.js.org/en/ and install it. 

Node.js comes with NPM install and it is required, because Express.js is an external node package, which needs to be added in a Node application. 

To show how that works, we will create a Node.js application and add Express.js to it. First, create a folder and then make changes to it.

Now, give the command ‘npm init’ to initialize a node app. We can leave most of the questions as default by pressing enter. But we'll give the entry point as server.js. We’ll also assign an author. And finally, enter ‘yes’ for the last question. 

This creates a package.json file will in the same directory, and we can install npm packages now.   Then, we’ll add express in our Node.js application by giving the command npm i express from the same directory in the terminal.  

Next, we’ll create a file server.js in the root directory and add the below code in it. Here, we are first importing express and using it in an app. After that, we’re also declaring a port and making it equal to 3000. Next, we have a GET request to /, where we will send Hello Express to the client. 

Finally, we are listening at port 3000 for incoming requests. 

Now, we will start the express app by running the command node server.js from the terminal.

Then we will go to http://localhost:3000/ and see the text Hello Express in the browser. 

This is a frequently asked interview question on express.js.

Express.js framework is created with JavaScript, and we code which we write with it is also written in JavaScript.Express.js. This is one of the reasons for the rise of MEAN and MERN stack, in which JavaScript knowledge can be used to learn Angular/React at Frontend, MongoDB in the Database and Node.js and Express.js at the backend.

Express has an in-built route support, so a developer can write responses to specific URLs with ease. We can also pass parameters to these routes, which add to the capabilities of the app. Express also supports multiple templating engines, through which you can generate static HTML for a web browser. If you follow this approach, the pages will be generated by the server, and there will be no need to write client code in Angular or React.

Without Express.js, we would have to write complex logic in Node.js, which is both tedious and time-consuming. Express.js code is minimalistic, efficient, and easily understandable by programmers, and because of it easily scalable.

Node.js programs are really fast because they implement event loops and get rid of all inefficiencies. With the power of Node.js and ease of an Express.js, we can build the backend for powerful and scalable web apps in no time. 

There are three functions, which are available as arguments in Express.js route handler function. The route handler functions are get, post, put, delete, and others. These are mentioned below. 

• req - It is known as the request object, which is a callback function. In Express we receive the data from the client, using three different types of requests. They are req.params, req.query and req.body. 
• res - It is also known as the response object. It is used to send the response back to the client. With the res object you can send many types of responses, like res.send, res.render, res.download and more. 
• next - It is an optional callback function, which can be used to send the control to the next middleware or function. 

We will take a small example containing all three arguments. We need to create a Node.js application first by creating a folder and adding node by npm init -y command. 

After this, we will install express in it using npm i express command.

Next, we’ll create a file with the name server.js and add the below code in it. Here, we shall first see the use of next() to pass control to the next function. After that with res.send() we will send the text Node.js Developer to the client. 

We also have a route to get the id of the user with req.params.id. 

Now, start the server with node server.js from the command line and then go to http://localhost:3000/ in the browser. We will see the below messages in the terminal.

Also, if we go to the route like http://localhost:3000/22, we will get the below console log in the terminal.  

Expect to come across this popular question in Express.js interview questions for freshers.

We can use Node.js directly for backend programming and there is no need to use Express.js. Actually, Express.js is a Node.js framework and it adds to the ease of programming and scalability of Node.js. We can also code the frontend in JavaScript, without going through frameworks like React and Angular. But we rarely have a large web-app in Vanilla JavaScript. 

Similarly, it’s not scalable to write the complete app in Node.js, because the code becomes complex very soon. So, we write the Node.js code with its framework of Express.js. The code for Express.js is very simple, minimalist, scalable, and can be learnt by a JavaScript developer in no time.

So, we don’t use Express.js over Node.js but with Node.js. We take the speed and performance of Node.js along with the simplicity of Express.js to create scalable and performant web-apps APIs. This is the reason, we never use Node.js without Express.js in production and they always go together. Node.js along with Express.js, is part of two popular stocks i.e., MEAN stack and MERN stack.

The growth of Node.js should be credited to Express.js also, which has made Node.js really easy to use. Just as bootstrap led to the success of CSS, similarly Express.js led to the success of Node.js. 

Yes there are many alternatives to Express.js and some of them are even better then Express.js. ExpessJS was released around the same time as Node.js i.e., in 2010. So, it has become the de-facto framework for Node.js.  

But since JavaScript added a lot of exciting and easy to use features with ES6 in 2015, the Express.js framework was not able to use it well. One such feature is async-await which is not that easy to use in Express.js. But the new frameworks like Koa, Fastify implement such features very well. We will look into two popular Express.js alternatives next. 
 
Fastify - As the name suggests it’s a Fast framework for Node.js, which can serve up to 30 thousand requests per second. It comes with async-await support out of the box, which can be easily used in the code. We can extend it via hooks and plugins. Fastify is also TypeScript ready, in which you can use TypeScript out of the box.  

Below is a small example to create a simple GET route in Fastify. We are using async-await through which we can handle promises and errors better. For the below code to work, we need to install Fastify in our Node application by below command. 

 npm i fastify 

Now, we can go to http://localhost:3000/ and see the correct output.

Koa - It is a modern and new framework for Node.js. Infact the Koa framework is created by some of the people in the Express.js team. It has been built ground up to use modern ES6 features like async-await and generators. One of Koa’s drawbacks is that it doesn’t come with an inbuilt router, and we need to install an external library of koa-router. 

So, we need to add these packages to a Node.js application, in order to use Koa. 

npm install koa@2.13.1 @koa/router@10.0.0 

Now, we can go to http://localhost:8080/  and see the correct output. 

Scaffolding is the process of creating a skeletal structure of a project. The production projects require a lot of modules to be added in the project before even starting to write the code. This is where scaffolding is used and there are many packages available for it in Express. We will now look at a scaffolding project.

The express-scaffolding-cli is a simple and easy to use scaffolding tool, which creates a complete express project with just giving the project name.

We can use it with the latest npx command, without even installing it. So, we’ll give the command npx express-scaffolding-cli from the command line to create a new project.

It will create a project within no time and with it a new directory with scaffoldingEx will be created. So, we will change to it and npm install to add all the packages.  

Now, a project will be created with routes, middleware, authentication, and error handling. We only have to give the database name in the default.json file. You should have the MongoDB running locally through compass, for this setting. 

Now, we need to give the PORT number in the server.js file.

Now, in the terminal, we have to run the command npm run dev as per the documentation in https://www.npmjs.com/package/express-scaffolding-cli and our server will run successfully.

Now, go to  http://localhost:3000/ and we will be able to see the message of HomeRoute sent by the server.  

With Express.js Generator or simply express-generator, we can quickly generate a daily complex skeleton of an Express.js app. Now, the app generated comes with a lot of structures and even Jade template. 

To generate an app with express-generator, first we need to create a folder with the name of the app. After that go inside the folder and then give the command npx express-generator to create the app.

Now, we need to install the dependencies in the app with the npm i command.

Finally, we will start the app with the npm start command.Now, we can go to http://localhost:3000/ and see that we have an html output.  

Our app starting point is app.js file, which contains all the required imports and it’s call to two routes.

The route at index.js contains the title of Express and this gets passed to the index.jade file.

Now, the templating engine of Jade, uses its own language to show the content in http://localhost:3000/  

As we can see from the above example, a fairly complex app was set up with different routes and templates. These templates will be shown on the client browser, when they reach the endpoints. 

By using the templates, we don’t even need a frontend client code and the code will be generated by the backend itself.

By default, debugging is turned off in Express.js. As Express.js and in turn Node.js are not meant for the browser, so we cannot see the logs in the browser console. 

To turn on logging, we have to use a bit of a different command depending on the operating system, when we are launching the application. On a UNIX operating system, we use the below command. 

$ DEBUG=express:* node index.js 

But on a Windows operating system, we use a different command: 

> set DEBUG=express:* & node index.js 

We will create a small Express app and enable debugging to check it out. First we need to create a new folder and change directory. After that we shall use the npm init command with -y option, to create a package.json file, which is a must for any Node.js app. Notice that we have given the -y option, else we would have to answer a lot of questions. 

Next, we will install express in our app by the below npm command, as it comes as an external package.

Now, create a file index.js and add the below code in it. This simple code will send the message Hello World, when someone goes to the home route from a browser.

Now, instead of running the node command by node index.js , we will run by the command which we have learned earlier.

Now, our advanced debugging is enabled in an Express App.  

Pino is a small and fast logger, which can be used in express apps. It logs additional information which is very useful for debugging.

First, we need to create a new folder and change directory. After that we use the npm init command with -y option, to create a package.json file, which is mandatory for any Node.js app. Notice that we have given the -y option, or else we would have to answer a lot of questions.

Next, we will install express and two pino packages. One is for normal logging and the other is for http logging. 

Now, create a file index.js and put the below code in it. Here, we are first importing express, pino-http and pino. The log from the app.get() is using the pino-http module and has been done by req.log.info(). The simple log inside app.listen is using the simple pino, with logger.info(). Also notice that we can pass the number separately in it.  

Now, when we run the app with node index.js, we will get the detailed log which includes the timestamp, pid and hostname also. 

Now, go to http://localhost:3000/ and we will get the detailed log of the http request being made.

It's no surprise that this one pops up often in Express.js questions.

The debug logger is more like our console logs, but it shows the log in a beautiful and colorful way. Additionally, you can turn certain modules on and off for logging. Let’s take a look at an example. 

We need to first create a new folder and change the directory. After that, we need to create a Node.js application by giving the command npm init -y. Next, we will install express, debug and http modules in it by giving the command npm I express debug http from the command line. 

Now, we are creating a basic app with the http module and enabling logging in it. The line const log = debug(‘http:server’), means that our server is called by that name. 

Now, when we go to the terminal and give the command DEBUG=http:server node index.js , we will see the below output from Line 6 and Line 12.  

Now, go to http://localhost:3000/ and we will see the log output from Line 9 from index.js in our console. 

As mentioned earlier, one of the main features of the debug logger is to do selective logging. To show that we will create a fake error in our app, which is using setTimeout() and running after 1 second. Also, notice that we have a new errorLogger with the name http:error declared.  

Now, to see only this log, we have to change our command in the terminal to DEBUG=http:error node index.js , we will see the below output fromLine 13, after 1 second. 

Now, if we turn on all the logs with *, we will see all the logs in the terminal.  

An Express.js app is basically a Node.js app, with express installed in it. We have to create a basic Node.js app and then add express to it, which is available as an external npm package.

So, open any terminal and create a directory and then navigate to the directory using the cd command. After that create an NPM project by giving npm init -y command. If we omit the -y flag, we have to respond to some questions manually with ‘yes’.

Next, we need to install the express package through npm. 

Now, create a file index.js in the route directory and add the below lines in it. The first line is used to import the express module, which we have just installed. The second line is used to create our app variable, using express. We are going to use this app variable throughout our app.  

The next lines of code tell that we are doing a GET request, using the app which we have previously created. It takes two parameters and the first one tells the path on which this action will be taken. It is also known as route and it is ‘/’ in our case. 

The next argument is “req” and “res”. Here, the ‘req’ is the request which was sent to the server and the ‘res’ is the response, which will be sent back from the server. We will be sending back a simple text of Hello Express to the client.

Lastly, we will listen to some port for the request. We generally listen to port 3000 for backend, but we can take any port. Also, notice that we have a second argument to listen function, which is generally used for logging.Now, we will start the server from the terminal by giving the command node index.js and we will get the output of the log.

Lastly, in any browser go to http://localhost:3000/ and you will see the response from the server.  

The request object is used to handle the data which comes to the server through string or JSON object. Express will receive data from clients through three types of req objects i.e., req.params, req.query and req.body. We will learn in detail about it through examples.

First, we shall create a simple Node.js project and install express in it. We will do it by creating a new folder and then changing to it. After that, giving the command npm init -y to create a Node.js project. After that we will install express in the app by giving npm i express command.

Now, we will create a file server.js and add the below code in it. First, we are doing the required imports while also listening on PORT 3000 for incoming requests. Now, with req.params we can get the data passed in the url. 

Now, go to http://localhost:3000/22 in any browser and we will see the id in the running server. 

We generally get the data from the client in a POST request through a JSON object. We will add a new /login path in which we are console logging the email and password from req.body. 

Notice that we need to use a middleware of app.use(), so that we can receive json. Also, we need to send back a success request with res.send() to the client.

Now, we need to send a POST request through Postman, or else create a frontend and take the data from the user and submit it as a JSON object. 

In Postman, we send a JSON object with email and password. 

Now, with the server running, we will get both email and password received on the server. 

The response object or the res object, is used to send the data back to the client. It generally happens after the request is sent from the client in the req object. So, it is a part of the request and response cycle. 

Now, with the res object we have many methods like send(), status(), append(), redirect() and render(). We will look at some of them through an example. 

We need to first create a simple Node.js project and install express in it. We will do it by creating a new folder and then changing to it. After that, giving the command npm init -y to create a Node.js project. After that we will install express in the app by giving npm i express command. 

Now, create a file server.js and add the below code in it. First, we are doing the required imports and listening on PORT 3000 for incoming requests. Now, with req.send we can send any data, when the user comes to the / route. 

Now, when we go to the / directory from the browser, we will get Hello Express shown. 

Next, we will look at res.redirect, which will redirect any route to the other route. In our case if we go to /help, we will be redirected to /user. 

Now, when we go to localhost:3000/help we will be redirected to http://localhost:3000/user in the browser and will see the user path text.  

We have also created a route in which if we go to any route other than the one done earlier, we will get Page Not Found text and also a status of 404 will be sent. We are using both res.status() and .send() chained to it. 

Now, go to any non-existent route and we will shown Page Not Found text.  

Next is a function in Express.js, which can be passed along with res and rep objects. It is used to pass control to the next middleware. There can be cases where we don’t want to complete the function in the current middleware and do the additional task in the next middleware. In these cases, next() is useful. 

We will go through a simple example to understand the same. We will first create a new Node.js application by creating a directory and changing to it. Then will initialize a package.json file with the npm init -y command. 

Next, we will install express in the app by giving the npm i express command.  

Create a new file index.js in the root directory and add the below code in it. Here, we have two middleware, and we want to pass the control from the first to the second. 

But notice in the first, we are not using the next function. 

Now, run the server by node index.js command and go to the localhost:3000 from the browser. We can see that we only got the first message and not the second message from the second middleware.

Now, we will add next() in the first middleware and this is where the control will be passed to the second middleware.

Now, again run the server by node index.js command and go to the localhost:3000 from the browser. We can see the messages from both middleware and were able to pass the control from the first to the second one. 

A common question in Express.js interview questions and answers, don't miss this one.

To send data from client browser to server, we have many methods. We can also pass the data as a query parameter using GET requests. But it is not advisable to send through GET because the data will be exposed in the query parameter in the browser link. 

To send data the POST request is created and we should send through it only. We are going to send the data through POST in express and going to learn about it next.  

We will first create a new Node.js application by creating a directory and changing to it. Then will initialize a package.json file with the npm init -y command. 

Next, we will install express in the app by giving the npm i express command. 

Now, create a file server.js and import express and give a port. After that we are using a middleware for json. It is required because we are going to pass our data as JSON to the backend.

Next, we will create a post request and pass the name and email in the body. We have also created a function .listen() to listen for the function in localhost port 8080.

Now, for checking our POST request, we need to use a postman app. Here, we need to send the application header as JSON and in the body pass name and email as json objects. 

After that hit the Send button and the POST request will be sent successfully to the server.

To download a file through Node.js requires a lot of effort and the code can get complicated soon. But the process is very easy with express.

We will see the same through a small example app. First create a new Node.js application by creating a directory and changing to it. Then will initialize a package.json file with the npm init -y command. It will give all options as yes and if we don’t give it, we will have to manually type yes.

Next, we will install express in the app by giving the npm i express command.  

Next, add an image file in the root directory. We’ll add desktop.jpg in the root directory.

Now, create a new file index.js. First, we will import the required express import. Then we have an app.get() function for the home directory. Now inside the get function, in the response object we are using the download function and passing our image desktop.jpg. 

Lastly, we are listening at port 3000 for incoming requests. 

After that start the node server by giving node index.js in the terminal.

Now, when we go to localhost:3000 the image file desktop.jpg will be downloaded automatically.

Models are required in Express JS, when we are integrating Express with databases, especially MongoDB databases. It defines the way in which the data will be stored in the MongoDB database. Let us understand it through an example. 

We will first create a new directory, then change directory and initialize a Node project with the npm init -y command.

After that we also need to install the package of express and mongoose. 

Next, we need MongoDB running from the cloud or local system. We have the local MongoDB running on our system and showing through Compass.

Now, create a file server.js and here, we shall first import express and mongoose. After that, we shall create a simple GET route. Next, we will use mongoose to connect to our local running database through mongoose.connect(). 

Now, we are using mongoose.connection.once() to open the database connection and show the success or the error messages, depending on the status. 

Finally listening to incoming requests on port 3000. Now, in the terminal run the server by node server.js command and we will see the message that it was able to connect to the database successfully. 

Now, we will create our model for the database. So, create a folder Models in the root directory and create a file emp.js in it. Here, we are creating a schema for the employee which basically contains the structure. So, we have empName and empEmail in the schema.

Now, we will use this Model in our server.js file. We need to import the Model first and also use the express.json(), because we are going to send json data. 

Next, create a POST route to add the employees. Here, we are using our model to send the empName and empEmail. After that we are using emp.save() to save the data in the MongoDB database.

Now, we will send the POST request from Postman as JSON object and it will be a success. 

We can also check in MongoDB Compass to see if the data got saved successfully.  

A template engine is used to write static code of HTML files. All of these template engines have their own language and are used to write the code for templates. When a client goes to any route which serves a template file, these template engines convert them in pure HTML code and send them back to the client. 

This is a very efficient and fast way to generate HTML files at the server, instead of relying on frontend client-side code through languages like Angular, React, or Vue. 

The popular template engines for Express are Pug, Handlebars, Mustache, and EJS. Let’s look into an example of Pug, which is one of the most popular templating engines.  

First create a new Node.js application by creating a directory and changing to it. Then initialize a package.json file with the npm init -y command. It will give all options as yes and if we don’t give it, we will have to manually type yes. 

Now, install express and pug into the node application by using the command npm i express pug in the terminal.  

Now, create a file server.js in the root directory and put the below code in it. Here, we are first importing express and then setting it to app. Now, with this app we are using pug as our view engine. 

After that we are having a GET function to /. Inside the GET function, the res object is rendering the home. 

Lastly, we are listening to all incoming requests are localhost 3000. 

Now, create a views folder and inside it home.pug file. Now, in this file we will put a h1 and a p with content. Notice the coding style for pug, which is totally different compared to html.

Now, go to http://localhost:3000/ and we will get the pug file rendered as html on the browser.  

One of the most frequently posed Express.js interview questions for experienced, be ready for it.

Sometimes we need to get the full URL in the server, and we can do it through the express app. We will look into the same in this example. 

We will first go through the basic setup step and create a new Node.js application by creating a directory and changing it. Then will initialize a package.json file with the npm init -y command.

Next, we will install express in our app by giving npm i express from the command line.

Now, create a file server.js and add the below code in it. Here, we have an app.get(), which is looking at all routes. Here, from the request, we are first getting the protocol which is basically the type of request - http or https. 

Next, we are getting the host which can be any address on the internet or localhost. We are also getting the URL, which is basically the part which comes after the localhost. Next, we are also getting the port on which the request is coming. 

After that we are just constructing the full URL, using all the parameters and sending back to the client. 

Now, start the server with node server.js in the command line. After that go to any url and, we will get the complete URL printed.  

A cookie is a small text file, which is stored in the client browser. When a client visits any website, through their browser and logs in to the site or fills some kind of a form, this data will be passed back to the client from the server, with some unique id which identifies the user computer. 

Now, whenever the user visits this website the saved data like username and password will be auto filled. And the user can also be given a unique experience like adding their name in login. 

The modern-day cookies are also known as HTTP cookies as they are used for internet browsing. It got its name from the Magic Cookies, which were before the internet era and used to store login information to a database system. 

There are mainly two types of cookies - 

• Session cookies - This is a temporary cookie, which gets deleted once we close our browser. This type of cookie doesn’t store the user information and generally is used to store some form data, filled by the user. 
• Persistent cookies - They are permanent forms of cookies and stored in the user hard-disk. They are used to track the user's behaviour and other things. By user behavior we mean the Web-surfing behaviour of the user. 

The session and the cookies are both used to store user information for various purposes. They help the data to be passed between different parts of the website. There is a difference between a session and cookies.  

Sessions are saved on the server side i.e., in the case of an Express server, it will be stored on the stored server. But they are also temporary and get deleted the moment the user goes away. Suppose a user logs into a site, then their data will be stored in the session variables, for better programming purposes. The data stored in the server is also very much secure in comparison to the client and cannot be easily compromised. Each session of a user is unique so separate data is maintained for the same. 

On the other hand, a cookie is a text file of a maximum size of 4KB, which is stored on the client computer. It is always stored as a string and is sent the first time the user visits the website. Cookies have many uses and they also used to keep track of users’ web-surfing behaviour, by tracking their browser history. Like when you visit a popular video streaming site and surf videos, the next time that site will show videos based on your earlier visit.

Cookies are an important part of any backend project. They are used for various tasks like saving user information, form, data, and others. We will learn how to implement cookies in an Express.js project. 

First create a project directory and go to it. After that initialize a node project by giving the command npm init -y from the terminal. 

After that we will install express and cookie-parser in the project. The cookie-parser helps us to manage the requests made by the user to the server. 

Next, create a file server.js and inside it, put the below code. We are importing the express and cookie parser first. After that we will use express through the app and through the app using the cookie. 

Next, in an app.get in the root directory, we are using res.cookie() to send cookie data from the server to the client browser. Next, we are just sending a message to the client browser, that the cookie was saved successfully. 

Now, in the browser go to http://localhost:3000/ and we will see the message Cookie Saved Successfully. After that  open the developer tools and Go to Storage and then expand Cookies and we will see our cookie been saved.

 Express and Django are both used for backend development, but they are different in many ways. These are the main differences in both platforms: 

• Express is a framework of Node.js, which in turn is a JavaScript framework for backend development. On the other hand, Django is a python framework for backend development. 
• Express is a lot like ReactJS which is a light-weight JavaScript frontend library and you need to install npm packages to add functionalities to it. On the other hand Django is like the JavaScript frontend framework of Angular, which has almost everything included in it. But this makes both Angular and Django harder to learn and implement. 
• Performance wise Express is way ahead of Django and that is the reason, it is used in production projects more. In comparison to it Django is used in hobbyist projects more and used by python programmers. 
• In Express.js, we can develop Full-Stack apps without even using Frontend libraries like React. This is done by using templating engines like EJS to output HTML, CSS and JS codes . On the other hand, it is not possible in Django and we have to develop the frontend separately.

Use the express.static middleware to serve static files in Express.js. 

Description: In Express.js, you can serve static files, such as images, CSS, and JavaScript, using the built-in express.static middleware. This middleware serves files from the specified directory.

Example: 

const express = require('express'); 
const app = express(); 
 
app.use(express.static('public')); 
 
app.listen(3000, () => { 
  console.log('Server is running on port 3000'); 
}); 

In this example, any file in the public directory can be accessed via http://localhost:3000/filename. 

A staple in Express.js interview, be prepared to answer this one.

The method responses or the res object is the response sent by the server to the client. There are many types of responses which can be sent to the client and we will look into them next. 

The most common method for res object is the .send(), through which we can send any data to the client. Below is a common example for the same. 

Here, if the user goes to the / route in their browser they will be shown the Hello Express text on the browser. 

We can also send the status code with the .status() method. These HTTP status codes are very important and interpreted by the client browser as success or failures. In the below example, we have also chained the send method. 

There is a shorthand syntax also, which combines both status and send method chaining. The method is called .sendStatus(), and it is used as below.  

We can also define headers in our responses to the client and for this we have the .append() method. Below is an example of the same.  

The .redirect() method is a very important one, as it can redirect to any route in the web-app. We have to just pass the route as a parameter.  

We can also prompt the client to download a file with the .download() method. Below is an example of the same.  

Express can connect to different types of databases. It can connect to NoSQL databases and Relational databases also. It connects very well with the two popular databases - MySQL and MongoDB. We will see to connect it to a MongoDB database next. 

First, we will go through the basic setup steps and create a new Node.js application by creating a directory and changing to it. Then will initialize a package.json file with the npm init -y command.

Now, we will install the required package of express and also the package of mongoose. Mongoose is a package built for express applications, which makes it very easy to interact with mongoDB databases. We will install them with npm i express mongoose from the command line.  

Now, create a file server.js in the root directory and add the below code in it. Here, we are first importing express and mongoose and after that using it in the app. We have also created a PORT and MONGOPORT variable with different values of 3000 and 5000. 

After that we are using mongoose.connect() to connect to the local MongoDB instance. If the connection is successful, we are showing a success message or else an error message. 

Lastly, we are listening to the connections at PORT 3000. 

Now, from the terminal run the command node server.js and we are successfully connected to mongoDB.

We need to show errors or the well-known 404 page to users who go to a non-existent page in our website. We will learn to do that next. 

We will first go through the basic setup to create a new Node.js application by creating a directory and changing to it. Then will initialize a package.json file with the npm init -y command. If we don’t specify the -y flag, we need to hit enter to a lot of default fields. 

Next, we will make it an express app by adding the express package through npm.  

Now, we will create a file server.js in the root directory. Here, we are first doing the import for express and then using it in the app. 

Now, we have three routes here, first for the home and second for contact. The third one contains ‘*’ and it contains all the routes not present in the first two. If a user tries to go to some route which is not mentioned, they will be shown ‘Page not Found’. 

One thing to keep in mind, is that this wildcard(‘*’) route, should always be the last route in our code. 

Lastly, we are listening to all client requests on port 3000. 

Now, start the server by giving node server.js in the terminal.

Now, if we go to any route except / or /contact, we will be shown the error message.  

CORS stands for Cross-Origin Resource Sharing. It is enabled in the browser by default and because of it a client running on a different network, cannot access the server running on a different network. 

Here’s an example. First, we will have our Node runtime installed and created using npm init -y. We will also install express and cors in our Node.js app.

Now, we will have a simple Express server in which we are sending an array of objects to the client, when coming to home root.  

First start the node server by running node index.js from the terminal and navigate to http://localhost:3000/ and we will get the array of objects back.  

This is allowed because our server and client - both are in localhost. Now, to make the request from a different client network, we have to go to some other site. We are going to https://www.knowledgehut.com/ and opening the console. Here, we will be using the inbuilt fetch api to goto the server endpoint at 3000. 

Notice that we are getting a CORS error and not able to get the data. 

In order to allow requests to our server endpoint from knowledgehut.com, we need to add it in cors middleware. We have already installed cors earlier, so we are importing it first.  

Now, when we go back to knowledgehut.com, and give the same fetch request we will get the data back successfully.  

It is always a bad idea in production projects to have configuration data in the server.js file or the main file. In production projects for Express.js, we configure the properties in two ways. They are - 

• config.js - We store the DB and other configurations in the config.js file. We can even use the .env file, to store the secrets in this method. 
• config.json - We can also store our config properties in the config.json file and use it with require.js 

We will look into the config.js method to store the configuration properties. First, we will have our Node runtime installed and created using npm init -y. We will also install express and mongoose in our Node.js app. 

Now, create a file config.js and in this file, we will store all the configuration related to our project. 

Here, we are storing the app and db configuration both, which in small projects we give in the root file only. 

Next, create a file db.js and in it we can use the configurations from config.js file directly by just importing it and using it.  

Here, we are just de-structuring the config object and taking the db values from it. After that we are further de-structuring and taking the host, port, and name from it. 

After that create a file App.js and inside it alo, we are using the data from the config object in the config.js file.  

Now, when we run the node app.js command, we will see the port number correctly connecting.

Routing is the way in which the server responds to a clients request to a particular path, when it comes through different protocols like GET, POST, PUT, DELETE. In common words, it is the function which gets called then the user goes to a URL on the web-app.

We will look at basic routing through an example. So, we will first set up the Express JS application by creating a Node.js runtime, through npm init -y command.

After that, install express in it through npm i express command.

The basic routing is done through app.method(path, callback) function. In our example, we are using the get and the post methods. 

The app.get(), have a route to the root directory and just sends a text back to the client browser. 

The app.post(), have a  /submit route in which we are logging the plain text, which we will receive from the client browser. After that we are sending the ‘Data received Successfully’ message to the client browser. 

First start the server by giving node server.js in the terminal. Now, check the GET route go to http://localhost:3000/ from the browser and we will see the text Hello Express in it.

The POST route requires a form to be submitted from the frontend, or we can do it from the postman app. Here, we are sending a plain text, because our server is expecting a plain text.   

Now, in the server logs also we are receiving the text, which we have sent.  

We can also use modular routes using express.router(), with which we can reuse a route. Create a new file router.js and add the below content in it. Here, we are using the router.route() to the same path. After that we have a .get() and .post() route.   

Now, we will use the routes in the app.js file. Here, we are importing the router.js file and after that with app.use(), using it in different ways.     

Now, go to http://localhost:3000/dev/nabendu/22 and we will get the welcome text served from router.js file.     

We can also do a POST request from http://localhost:3000/tester/shikha/24 and we will get the Data received text served from router.js file.

JWT stands for JSON Web Tokens. They are a very secure way of authentication of the client with the server. Let's look at an example, where we will get the JWT token of a specific user. We will be generating it on the server and sending it back to the client. Each client will have a unique JWT token. 

We will first set up the Express JS application by creating a Node.js runtime, through npm init -y command. After that we are installing express, jsonwebtoken and dotenv in it through npm i express jsonwebtoken dotenv command. 

Next, create an .env file and give a TOKEN_SECRET in it. We can use any long random string in it.  

Now, create an app.js file. Here, we are first doing the required imports of express, jwt and dotenv. After that we are using the express.json and the dotenv. 

Next, we have a POST route with /api/create. Here, we are passing the username to a generateAccessToken() to receive the token and after that sending it back to the client in res.json() 

Now, in the generateAccessToken() function, we are using jwt.sign() and taking the username, our TOKEN_SECRET and expiry time to generate the JWT token.

After starting the server in terminal with node app.js, we will open Postman and do a POST request to http://localhost:3000/api/create  with the username as JSON and we will receive our unique JWT token.

Formidable is an easy-to-use NPM module, which is used to parse from data, especially when uploading files in an Express JS app. It is very popular and has got nearly half a million downloads on NPM. 

We will learn how to use it next. First create a new directory and change it. After that initialize a Node.js app by the npm init -y command. We are also adding the dependencies of express and formidable in it. 

Then, create a file index.js in the root directory. Also create an uploads folder in the root directory, in which we are going to store the uploaded files. 

Next, we are first importing express and after that the fs (File System) module. We are also importing path modules and formidable. 

We are using the app with express and with it creating a POST route using app.post(). Inside the post method, we are taking the data from the incoming form using formidable.  

Now, we are parsing the form and adding the incoming file to the uploads folder. We are also reading it using the fs module. 

Lastly, we are listening at port 3000 for incoming requests. 

Now, go to postman and create a POST request and make a key of profilePic and upload a file and send it.  

Now, when we check in the uploads folder the file is uploaded successfully in our server.  

We can use Multer to upload files in Express.js applications. It is an easy-to-use package which adds the capabilities to upload single or multiple files through Express.js. 

First, we shall create a new directory and change it. After that initialize a Node.js app by the NPM init -y command. We are also adding the dependencies of express and multer in it.

Next, we will create a server.js file and add the below code in it. Here, we are first importing express and multer. After that we are given the destination directory to store the uploaded file. 

We have created a POST route to upload a single file using multer, using the upload.single(). 

Next, we will start the node server by giving node server.js in the command line. After that in Postman, we will go to the /single route and upload a single file and send it. Give the options, as in the screenshot below. 

Now, we can see a new uploads folder been created and the file been uploaded in it.  

Now, we will create a new endpoint to upload multiple files through upload.array(). Here, we are also giving the max number of files that can be uploaded.  

Now, we will send multiple files from Postman to the /bulk route and it will be successful.  

The new files are also saved in the uploads folder.  

Express app doesn’t follow any defined structure, so sometimes it’s up to the developer or the Architect to create one. But when we don’t follow a structure, it is very difficult to maintain the project at the later stages when it grows. 

There are two types of Express projects. One which has the complete frontend and backend built with some templating engine. The other, and more popular one, is to have only RESTful routes built in Express, and a separate frontend which is generally ReactJS, Angular or Vue. 

We will look into the structure of a complete web app with express first.  

Here, we will have a config folder, which will contain all of our configuration details. It will have a different file for general config, one for credentials and one for database configurations. 

After that we will have our models folder which will contain the structure of the different data used in our project. 

Next, we will have a public folder. This folder will have the images, javascript and css folders which will contain the respective files. 

Next, we will have the routes folder, which contains our different routes used in the project. 

We will also have a views folder containing our template files like pug or EJS. These files get converted into actual HTML files during runtime and shown in the client browser. 

Finally, we will have the app.js files which is the entry point and connect to everything. We will also have a routes.js file, which is the central routing file and connects to the routes in the routes folder. 

The RESTful API design is much simpler and won’t contain the views and public folders, because we are not creating the frontend in it.  

We can generate these structures automatically by using any express generator package, while starting the project.  

We can use a lot of template engines in express, which are used to change a static file written in server to actual HTML content, to be displayed in the client browser. Some of the popular template engines, which works with express are below -  

• Pug(formerly Jade) 
• Mustache 
• EJS 
• Handlebars 
• Haml 
• Haml-coffee 
• Hogan 
• JUST 
• Underscore 
• Liquor 
• Swig 

We will now look into examples of one of the popular template engines, which is EJS. The syntax of EJS is quite similar to HTML code and we can also use dynamic content in it. 

First, we will go through the basic setup steps and create a new Node.js application by creating a directory and changing to it. Then will initialize a package.json file with the npm init -y command.  

Now, install express and EJS into the node application by using the command npm i express ejs in the terminal.  

Next, we will create a file index.js in the root directory and put the below code in it. Here, we are first importing express and then setting it to app. Now, with this app we are using the ejs as our view engine.  

After that we are having a get function to /. Inside the get function, we have a variable people first, containing an array of object people. Then we are using the res object to render a home component and passing people array to it. 

Lastly, we are listening to all incoming requests are localhost 3000. 

Once this is done, we will create a views folder and inside it home.ejs file. Now, in this file we will put an h1 and a p tag with content. Notice the coding style for EJS, is quite similar to that of an HTML code. Inside an ul tag, we are also looping through the people array, which we got from index.js and printing the name in li tags.

Now, just go to http://localhost:3000/ and we will get the EJS file rendered as html on the browser.  

It is very important to make the cookie secure or else it can be misused for cross-scripting attacks. For example, you can access the cookie which is stored in the browser by using the document.cookie command from the console.

There are several attributes available, while setting the cookie which generally make it more secure. Let's take a look at them with an example.  

First, create a project directory and go to it. After that initialize a node project by giving the command npm init -y from the terminal.  

After that we will install express and cookie-parser in the project.  

Now, create a server.js file in the same directory and add the below code in it. We are using res.cookie() here to send the cookie information to the client. But notice that we are also sending a third parameter which contains some parameters. Now, these means the following: 

• maxAge - It is the number of seconds after which the cookie will expire. 
• Expires - Similar to maxAge, but we can give the Date on which the cookie will expire. 
• secure - It means the browser will not accept cookies until it comes through a https connection. 
• httpOnly - The most important parameter, which ensures that the cookie cannot be accessed through JavaScript. It is the main thing which prevents cross-origin attack. 
• sameSite - It improves the security by stopping third parties from tracking users across sites. This is done, if it is set to lax. 

Now, in the browser go to http://localhost:3000/ and we will see the message Cookie Saved Successfully. After that, open the developer tools and Go to Storage and then expand Cookies and we will see the cookie being saved with Security values.  

There are many situations in which we want to delete cookies from the client browser. There can be situations, where we are told to delete cookies once the user logs out from the applications. We will look into an example to understand the same.

First create a project directory and go to it. After that initialize a node project by giving the command npm init -y from the terminal.  We also need to install express and cookie parser in the project.

Now, create a file server.js and add the below content in it. Here, we have a root route which stores the user information in a cookie named login info. Now, we have a /logout route and when the user navigates to it, the cookie login info is cleared, through the res.clear cookie function. We are passing the name of the cookie to be cleared, which is login info.  

Now, we will go to http://localhost:3000/ and we will see the message Cookie Saved Successfully. Now in the developer tools open Storage and then expand Cookies and we will see the cookie being saved.

Next, go to the route http://localhost:3000/logout and you will see the message Cookie loginInfo cleared and also in the Storage tab, there is no cookie information.  

To create an HTTP Server with Express.js, we need to serve HTML pages. We can serve the HTML code with templating engines like EJS also, but here we will directly serve the HTML, CSS, and JavaScript files.

First, we will have our Node runtime installed and created using npm init -y. We will also install express in our Node.js app.

After that, we will create a public folder and an index.html file in it and put the simple content in it.  

Next, we will create a style.css file in the public folder. Here we are giving the styles for a beautiful gradient background..  

Now, create a main.js file in the public folder. Here, we had put the code for a simple alert.  

Then, we will create the server.js file and import the path and express. After that we are using app.use and inside it using path, which is required to generate static paths and serve static assets. 

And lastly, we are serving the index.html file through the sendFile.

Now, start the server by giving the node server.js in the terminal. When we go to http://localhost:8080/ and we will see this beautiful webpage with the alert.  

Custom middleware is implemented as functions that process the request and response objects. 

Description: Custom middleware functions can be created to perform specific tasks during the request-response cycle.  

Example: 

function customMiddleware(req, res, next) { 
  console.log('Custom middleware executed'); 
  next(); 
} 
 
app.use(customMiddleware); 
 

Use the mongoose library to interact with MongoDB in an Express.js application. 

Description: MongoDB integration can be managed using the mongoose library, which provides a schema-based solution for interacting with MongoDB.  

Example: 

const mongoose = require('mongoose'); 
 
mongoose.connect('mongodb://localhost/test', { useNewUrlParser: true, useUnifiedTopology: true }); 
 
const UserSchema = new mongoose.Schema({ 
  name: String, 
  email: String 
}); 
 
const User = mongoose.model('User', UserSchema); 
 
app.post('/user', (req, res) => { 
  const user = new User(req.body); 
  user.save().then(() => res.send('User saved')); 
}); 
 

Use the passport middleware to handle authentication in Express.js. 

Description: Authentication can be managed using the passport middleware, which supports various authentication strategies.  

Example: 

const passport = require('passport'); 
const LocalStrategy = require('passport-local').Strategy; 
 
passport.use(new LocalStrategy((username, password, done) => { 
  // Find and authenticate user 
  done(null, user); 
})); 
 
app.use(passport.initialize()); 
app.use(passport.session()); 
 
app.post('/login', passport.authenticate('local', { 
  successRedirect: '/', 
  failureRedirect: '/login' 
})); 

Implement RBAC by defining roles and permissions and checking them in middleware. 

Description: RBAC can be managed by defining roles and permissions, and then creating middleware to check user roles before granting access.  

Example: 

function checkRole(role) { 
  return (req, res, next) => { 
    if (req.user && req.user.role === role) { 
      next(); 
    } else { 
      res.status(403).send('Forbidden'); 
    } 
  }; 
} 
 
app.get('/admin', checkRole('admin'), (req, res) => { 
  res.send('Admin page'); 
}); 
 

Use the socket.io library to handle real-time communication in Express.js. 

Description: Real-time communication can be managed using socket.io to create WebSocket connections.  

Example: 

const http = require('http').createServer(app); 
const io = require('socket.io')(http); 
 
io.on('connection', (socket) => { 
  console.log('User connected'); 
  socket.on('message', (msg) => { 
    io.emit('message', msg); 
  }); 
}); 
 
http.listen(3000, () => { 
  console.log('Server is running on port 3000'); 
}); 
 

Secure Express.js applications using middleware like helmet, cors, and by following best practices for input validation and authentication. 

Description: Common security threats can be mitigated by using security-focused middleware and best practices.  

Example: 

const helmet = require('helmet'); 
app.use(helmet()); 
 
const cors = require('cors'); 
app.use(cors()); 
 
app.use(bodyParser.json()); 
app.use(xssFilter()); 
 
function xssFilter() { 
  return (req, res, next) => { 
    req.body = sanitize(req.body); 
    next(); 
  }; 
} 
 

Use supertest to write integration tests that test multiple parts of the application together. 

Description: Integration tests can be written using supertest to test the interaction between different parts of the application.  

Example: 

const request = require('supertest'); 
const app = require('../app'); // Path to your Express app 
 
describe('POST /user', () => { 
  it('creates a new user', (done) => { 
    request(app) 
      .post('/user') 
      .send({ name: 'John', email: 'john@example.com' }) 
      .expect(200) 
      .expect((res) => { 

Use a combination of error handling middleware and logging libraries like winston to manage and log application errors. 

Description: Errors can be managed using error handling middleware and logged using libraries like winston.  

Example: 

const winston = require('winston'); 
 
const logger = winston.createLogger({ 
  transports: [ 
    new winston.transports.Console(), 
    new winston.transports.File({ filename: 'error.log' }) 
  ] 
}); 
 
app.use((err, req, res, next) => { 
  logger.error(err.message); 
  res.status(500).send('Something went wrong!'); 
}); 

Define Mongoose models and create CRUD routes in Express.js to implement a RESTful API. 

Description: A RESTful API can be implemented by defining Mongoose models for the data and creating routes to handle CRUD operations.  

Example: 

const mongoose = require('mongoose'); 
const express = require('express'); 
const app = express(); 
 
mongoose.connect('mongodb://localhost/test', { useNewUrlParser: true, useUnifiedTopology: true }); 
 
const UserSchema = new mongoose.Schema({ 
  name: String, 
  email: String 
}); 
 
const User = mongoose.model('User', UserSchema); 
 
app.use(express.json()); 
 
app.get('/users', async (req, res) => { 
  const users = await User.find(); 
  res.send(users); 
}); 
 
app.post('/users', async (req, res) => { 
  const user = new User(req.body); 
  await user.save(); 
  res.send(user); 
}); 
 
app.listen(3000, () => { 
  console.log('Server running on port 3000'); 
}); 

Error handling middleware is defined by a function with four arguments: err, req, res, and next. 

Description: To handle errors, define middleware functions that accept an err argument before req, res, and next.  

app.use((err, req, res, next) => { 
  console.error(err.stack); 
  res

Query parameters are accessed using req.query. 

Description: Query parameters can be retrieved from the request object using req.query. 

Example: 

app.get('/search', (req, res) => { 
  const searchQuery = req.query.q; 
  res.send(`Search query: ${searchQuery}`); 
}); 

Use body-parser middleware to parse form data. 

Description: Form data can be handled by using the body-parser middleware to parse incoming request bodies.  

Example: 

const bodyParser = require('body-parser'); 
app.use(bodyParser.urlencoded({ extended: false })); 
 
app.post('/submit', (req, res) => { 
  res.send(`Form data: ${req.body.name}`); 
}); 

Use body-parser middleware to parse JSON data. 

Description: JSON data can be handled by using the body-parser middleware to parse incoming request bodies.  

Example: 

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

Use the multer middleware to handle file uploads. 

Description: File uploads can be managed using the multer middleware, which handles multipart/form-data.  

Example: 

const multer = require('multer'); 
const upload = multer({ dest: 'uploads/' }); 
 
app.post('/upload', upload.single('file'), (req, res) => { 
  res.send(`File uploaded: ${req.file.originalname}`); 
}); 

Define routes using app.get, app.post, and other HTTP methods. 

Description: Routes are defined by attaching handlers for specific HTTP methods to paths.  

Example: 

app.get('/', (req, res) => { 
  res.send('Hello World'); 
}); 
 
app.post('/submit', (req, res) => { 
  res.send('Form submitted'); 
}); 

Router-level middleware can be used by attaching middleware to an instance of express.Router(). 

Description: Router-level middleware works the same way as application-level middleware, except it is bound to an instance of express.Router().  

Example: 

const router = express.Router(); 
 
router.use((req, res, next) => { 
  console.log('Router-level middleware'); 
  next(); 
}); 
 
router.get('/', (req, res) => { 
  res.send('Home page'); 
}); 

app.use('/home', router); 
 

Use the cookie-parser middleware to handle cookies. 

Description: Cookies can be set and retrieved using the cookie-parser middleware.  

Example: 

const cookieParser = require('cookie-parser'); 
app.use(cookieParser()); 
 
app.get('/setcookie', (req, res) => { 
  res.cookie('name', 'value'); 
  res.send('Cookie set'); 
}); 

app.get('/getcookie', (req, res) => { 
  const name = req.cookies.name; 
  res.send(`Cookie value: ${name}`); 
}); 

Use the cookie-parser middleware to handle cookies. 

Description: Cookies can be set and retrieved using the cookie-parser middleware.  

Example: 

const cookieParser = require('cookie-parser'); 
app.use(cookieParser()); 
 
app.get('/setcookie', (req, res) => { 
  res.cookie('name', 'value'); 
  res.send('Cookie set'); 
}); 
 
app.get('/getcookie', (req, res) => { 
  const name = req.cookies.name; 
  res.send(`Cookie value: ${name}`); 
}); 

Use the dotenv package to manage environment variables. 

Description: Environment variables can be managed using the dotenv package to load them from a .env file.  

Example: 

require('dotenv').config(); 
 
app.get('/env', (req, res) => { 
  res.send(`Environment variable: ${process.env.MY_VARIABLE}`); 
}); 

Use the https module to create an HTTPS server. 

Description: HTTPS can be implemented by creating an HTTPS server using the https module and providing SSL certificates.  

Example: 

const https = require('https'); 
const fs = require('fs'); 
 
const options = { 
  key: fs.readFileSync('key.pem'), 
  cert: fs.readFileSync('cert.pem') 
}; 
 
https.createServer(options, app).listen(3000, () => { 
  console.log('HTTPS server running on port 3000'); 
}); 
 

Use the express-session middleware to manage sessions. 

Description: Sessions can be managed using the express-session middleware to store session data on the server side.  

Example: 

const session = require('express-session'); 
 
app.use(session({ 
  secret: 'secret', 
  resave: false, 
  saveUninitialized: true 
})); 
 
app.get('/session', (req, res) => { 
  if (req.session.views) { 
    req.session.views++; 
    res.send(`Views: ${req.session.views}`); 
  } else { 
    req.session.views = 1; 
    res.send('First visit'); 
  } 
}); 
 

Use the cors middleware to handle Cross-Origin Resource Sharing (CORS). 

Description: CORS can be handled using the cors middleware, which adds the necessary headers to the response.  

Example: 

const cors = require('cors'); 
app.use(cors()); 
 
app.get('/data', (req, res) => { 
  res.send('CORS enabled'); 
}); 

Use the express-validator middleware to validate input. 

Description: Input validation can be managed using the express-validator middleware to ensure data meets specified criteria.  

Example: 

const { body, validationResult } = require('express-validator'); 
 
app.post('/user', [ 
  body('username').isLength({ min: 5 }), 
  body('email').isEmail() 
], (req, res) => { 
  const errors = validationResult(req); 
  if (!errors.isEmpty()) { 
    return res.status(400).json({ errors: errors.array() }); 
  } 
  res.send('User data is valid'); 
}); 
 

Handle asynchronous code in Express.js using promises and async/await. 

Description: Asynchronous code can be managed using promises or the async/await syntax to handle asynchronous operations cleanly.  

Example: 

app.get('/data', async (req, res) => { 
  try { 
    const data = await fetchData(); 
    res.send(data); 
  } catch (err) { 
    res.status(500).send(err.message); 
  } 
}); 
 
function fetchData() { 
  return new Promise((resolve, reject) => { 
    setTimeout(() => { 
      resolve('Data fetched'); 
    }, 1000); 
  }); 
}