Express js Interview Questions and Answers

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.