Skip to main content

Other NodeJS theory

What is Express.js and what advantages does it provide when creating web applications?​

Express.js is a minimal and flexible Node.js web application framework that provides a robust set of features to build web and mobile applications. It simplifies the process of building a server-side application by providing a powerful API for handling HTTP requests and responses, routing, middleware, and more.

Advantages of Express.js:

  • Simplified Routing: Express.js provides a straightforward way to define routes and handle requests to different endpoints of your application.
  • Middleware Support: It allows the use of middleware functions to handle various aspects of HTTP requests, such as parsing request bodies, handling authentication, and managing sessions.
  • Extensibility: Express.js is highly extensible, meaning you can add third-party libraries or create your own to add custom functionality.
  • Flexibility: It doesn’t enforce a strict directory structure or limit your use of specific tools, allowing developers to structure their applications as they see fit.
  • Large Ecosystem: Express.js has a large ecosystem of plugins and extensions that can add various functionalities to your applications.

How to handle requests and responses in Express.js? Provide an example of routing​

In Express.js, you handle requests and responses by defining route handlers that correspond to different HTTP methods (GET, POST, PUT, DELETE, etc.). A route is a combination of a path and an HTTP method.

Example of Routing:

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

// Handle GET request to the root route
app.get("/", (req, res) => {
  res.send("Hello, World!");
});

// Handle GET request to /about route
app.get("/about", (req, res) => {
  res.send("About Page");
});

// Handle POST request to /submit route
app.post("/submit", (req, res) => {
  res.send("Form submitted");
});

// Start the server
app.listen(3000, () => {
  console.log("Server is running on http://localhost:3000");
});

In this example, different routes are defined using app.get() and app.post(). Each route is associated with a callback function that handles the request and sends a response.

Explain how middleware works in Express.js and how to use it?​

Middleware in Express.js refers to functions that have access to the request object (req), the response object (res), and the next middleware function in the application’s request-response cycle. Middleware functions can perform a variety of tasks such as modifying request/response objects, ending the request-response cycle, or passing control to the next middleware function.

Types of Middleware:

  • Application-Level Middleware: Bound to an instance of the app object using app.use() or app.METHOD().

  • Router-Level Middleware: Works similarly to application-level middleware, but is bound to an instance of express.Router().

  • Error-Handling Middleware: Has four arguments and is used for handling errors.

  • Built-in Middleware: Express comes with some built-in middleware like express.static() to serve static files.

  • Third-Party Middleware: Middleware provided by third-party libraries (e.g., body-parser for parsing request bodies).

Example of using Middleware:

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

// Application-Level Middleware
app.use((req, res, next) => {
  console.log("Time:", Date.now());
  next();
});

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

// Route with middleware specific to this route
app.get(
  "/user/:id",
  (req, res, next) => {
    console.log("Request Type:", req.method);
    next();
  },
  (req, res) => {
    res.send(`User ID: ${req.params.id}`);
  },
);

// Error-Handling Middleware
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send("Something broke!");
});

// Start the server
app.listen(3000, () => {
  console.log("Server is running on http://localhost:3000");
});

How to implement and use routes in Express.js?​

Routes in Express.js are implemented by defining endpoint handlers for specific HTTP methods (GET, POST, PUT, DELETE, etc.) on specific paths. These routes can handle requests to various URLs and execute corresponding code.

Example of Implementing Routes:

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

// Define a simple route
app.get("/", (req, res) => {
  res.send("Welcome to the Home Page");
});

// Define a route with a parameter
app.get("/users/:id", (req, res) => {
  const userId = req.params.id;
  res.send(`User ID: ${userId}`);
});

// Define a POST route
app.post("/users", (req, res) => {
  const user = req.body; // Assuming body-parser middleware is used
  res.send(`User ${user.name} added`);
});

// Define a DELETE route
app.delete("/users/:id", (req, res) => {
  const userId = req.params.id;
  res.send(`User ${userId} deleted`);
});

// Start the server
app.listen(3000, () => {
  console.log("Server is running on http://localhost:3000");
});

In this example, different routes are implemented to handle requests to the home page, user details, adding users, and deleting users. Parameters can be passed through the URL and accessed via req.params.

How to manage asynchronous operations in Node.js using callbacks, promises, and async/await?​

Managing asynchronous operations in Node.js can be done using callbacks, promises, and the async/await syntax.

Using Callbacks:

Callbacks are functions passed as arguments to other functions that are executed once an asynchronous operation is completed.

Example:

const fs = require("fs");

fs.readFile("example.txt", "utf8", (err, data) => {
  if (err) {
    return console.error(err);
  }
  console.log(data);
});

Using Promises:

Promises provide a more elegant way to handle asynchronous operations, allowing you to chain operations and handle errors more gracefully.

Example:

const fs = require("fs").promises;

fs.readFile("example.txt", "utf8")
  .then((data) => {
    console.log(data);
  })
  .catch((err) => {
    console.error(err);
  });

Using Async/Await:

async/await is a modern syntax built on top of promises that allows you to write asynchronous code in a synchronous manner.

Example:

const fs = require("fs").promises;

async function readFile() {
  try {
    const data = await fs.readFile("example.txt", "utf8");
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

readFile();

How to handle errors in Node.js? Provide examples of error handling in asynchronous operations.​

Error handling in Node.js, especially in asynchronous operations, can be done using various methods depending on whether you are using callbacks, promises, or async/await.

Error Handling with Callbacks:

In Node.js, it’s a common practice to pass an error object as the first argument to the callback function.

Example:

const fs = require("fs");

fs.readFile("nonexistentfile.txt", "utf8", (err, data) => {
  if (err) {
    console.error("Error reading file:", err);
    return;
  }
  console.log(data);
});

Error Handling with Promises:

When using promises, errors can be caught using the catch method.

Example:

const fs = require("fs").promises;

fs.readFile("nonexistentfile.txt", "utf8")
  .then((data) => {
    console.log(data);
  })
  .catch((err) => {
    console.error("Error reading file:", err);
  });

Error Handling with Async/Await:

In async/await syntax, errors can be handled using try/catch blocks.

Example:

const fs = require("fs").promises;

async function readFile() {
  try {
    const data = await fs.readFile("nonexistentfile.txt", "utf8");
    console.log(data);
  } catch (err) {
    console.error("Error reading file:", err);
  }
}

readFile();

What are WebSockets and how to implement their support in Node.js?​

WebSockets are a protocol that allows for full-duplex communication channels over a single TCP connection. They enable real-time communication between a client and a server, where both can send and receive data simultaneously.

Implementing WebSocket Support in Node.js:

To implement WebSocket support, you can use the ws library in Node.js.

Example:

const WebSocket = require("ws");

const wss = new WebSocket.Server({ port: 8080 });

wss.on("connection", (ws) => {
  ws.on("message", (message) => {
    console.log("received: %s", message);
  });

  ws.send("Hello! You are connected.");
});

In this example, a WebSocket server is created that listens on port 8080. When a client connects, it can send messages to the server and receive messages back.

How to set up and use a database (e.g., MongoDB, MySQL) in a Node.js application?​

To set up and use a database in a Node.js application, you typically need to install a corresponding library or client for the database you want to use.

Setting Up MongoDB:

To use MongoDB, you can install the mongoose library, which is an ODM (Object Data Modeling) tool for MongoDB.

Example:

const mongoose = require("mongoose");

mongoose
  .connect("mongodb://localhost:27017/mydatabase", {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  })
  .then(() => {
    console.log("Connected to MongoDB");
  })
  .catch((err) => {
    console.error("Error connecting to MongoDB", err);
  });

// Define a schema and a model
const userSchema = new mongoose.Schema({
  name: String,
  email: String,
  password: String,
});

const User = mongoose.model("User", userSchema);

// Create a new user
const newUser = new User({
  name: "John Doe",
  email: "john@example.com",
  password: "password123",
});

newUser
  .save()
  .then((user) => console.log("User saved:", user))
  .catch((err) => console.error("Error saving user:", err));

Setting Up MySQL:

To use MySQL, you can install the mysql or mysql2 library.

Example:

const mysql = require("mysql");

const connection = mysql.createConnection({
  host: "localhost",
  user: "root",
  password: "password",
  database: "mydatabase",
});

connection.connect((err) => {
  if (err) {
    return console.error("Error connecting to MySQL:", err);
  }
  console.log("Connected to MySQL");
});

// Query the database
connection.query("SELECT * FROM users", (err, results, fields) => {
  if (err) throw err;
  console.log("User data:", results);
});

// Close the connection
connection.end();

Explain how the Yarn package manager works and how it differs from npm.​

Yarn is a package manager for JavaScript that was created as an alternative to npm. It aims to address some of the shortcomings of npm by providing more stability, security, and speed in managing project dependencies.

Key Differences between Yarn and npm:

  • Speed: Yarn caches every package it downloads, making subsequent installations faster. It also installs packages in parallel, which speeds up the process.
  • Deterministic Dependency Resolution: Yarn generates a yarn.lock file that ensures the same dependencies are installed on every machine, reducing the "works on my machine" issue.
  • Security: Yarn checks the integrity of every installed package using checksums before running its code, providing an additional layer of security.
  • Workspaces: Yarn supports workspaces, allowing you to manage multiple packages within a single repository, which is useful for monorepos.

Example of using Yarn:

  • Installing Yarn:
npm install -g yarn
  • Installing Packages:
yarn add express
  • Installing All Dependencies:
yarn install
  • Running Scripts:
yarn start

What is JSON Web Token (JWT) and how to use it for authentication in a Node.js application?​

JSON Web Token (JWT) is an open standard used to securely transmit information between parties as a JSON object. It is commonly used for authentication and information exchange.

Structure of JWT:

  • Header: Contains the type of token (JWT) and the signing algorithm.
  • Payload: Contains the claims or the data you want to transmit.
  • Signature: Used to verify the token was not altered and was generated by a trusted source.

Using JWT for Authentication:

To use JWT for authentication in a Node.js application, you typically use the jsonwebtoken library.

Example:

const jwt = require("jsonwebtoken");

// Generate a token
const token = jwt.sign({ id: user.id, username: user.username }, "secretKey", {
  expiresIn: "1h",
});
console.log("Generated Token:", token);

// Verify a token
jwt.verify(token, "secretKey", (err, decoded) => {
  if (err) {
    return console.error("Token verification failed:", err);
  }
  console.log("Decoded Token:", decoded);
});

In this example, a JWT is generated with a payload containing the user’s ID and username. The token is signed with a secret key and has an expiration time of 1 hour. The verify function is used to decode the token and check its validity.

How to test Node.js applications? Provide examples using Mocha, Chai, or Jest.​

Testing Node.js applications is crucial to ensure that your code behaves as expected. Mocha, Chai, and Jest are popular testing libraries used for this purpose.

Using Mocha and Chai:

Mocha is a testing framework, and Chai is an assertion library that can be used with Mocha.

Example:

// math.js
function add(a, b) {
  return a + b;
}
module.exports = add;

// test/math.test.js
const add = require("../math");
const assert = require("chai").assert;

describe("Math Tests", () => {
  it("should return 4 when adding 2 and 2", () => {
    assert.equal(add(2, 2), 4);
  });

  it("should return a number", () => {
    assert.typeOf(add(2, 2), "number");
  });
});
  • Running Tests with Mocha:
mocha

Using Jest:

Jest is a full-featured testing framework with built-in assertions, mocking, and coverage tools.

Example:

// math.js
function add(a, b) {
  return a + b;
}
module.exports = add;

// math.test.js
const add = require("./math");

test("adds 2 + 2 to equal 4", () => {
  expect(add(2, 2)).toBe(4);
});

test("should return a number", () => {
  expect(typeof add(2, 2)).toBe("number");
});
  • Running Tests with Jest:
jest

Write the steps for setting up an Express.js application.​

Setting up an Express.js application involves the following steps:

  • Install Node.js: Ensure that Node.js is installed on your machine.
  • Initialize the Project: Create a new directory for your project and initialize it using npm.
mkdir my-express-app
cd my-express-app
npm init -y
  • Install Express.js: Install Express.js via npm.
npm install express --save
  • Create the Application File: Create a file named app.js (or any name you prefer) and set up a basic Express server.
const express = require("express");
const app = express();

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

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});
  • Run the Application: Start the server by running the following command.
node app.js
  • Access the Application: Open a browser and navigate to http://localhost:3000 to see the output.

What function arguments are available to Express.js route handlers?​

In Express.js, route handlers have three main arguments:

  • req (Request): The request object contains information about the HTTP request, such as query parameters, body data, headers, and the request URL.
app.get("/user", (req, res) => {
  console.log(req.query); // Access query parameters
  console.log(req.body); // Access body data (requires middleware like express.json())
  console.log(req.headers); // Access headers
});
  • res (Response): The response object is used to send a response back to the client. It provides methods for setting status codes, sending data, rendering templates, etc.
app.get("/user", (req, res) => {
  res.status(200).json({ message: "User data" });
});
  • next (Next Function): The next function is used to pass control to the next middleware function in the stack. If not used, the request-response cycle will be left hanging.
app.use((req, res, next) => {
  console.log("This middleware runs for every request");
  next(); // Passes control to the next middleware or route handler
});

How to configure properties in Express.js?​

Configuring properties in Express.js can be done using the app.set() and app.get() methods. These methods allow you to set and retrieve various configuration options for your Express application.

Common Configurations:

  • Setting the View Engine:
app.set("view engine", "ejs");
  • Setting the Port:
app.set("port", process.env.PORT || 3000);
  • Accessing Configuration Values:
const port = app.get("port");

Example:

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

// Set various configurations
app.set("view engine", "ejs");
app.set("port", process.env.PORT || 3000);

// Access configuration value
console.log("Server running on port", app.get("port"));

// Start the server
app.listen(app.get("port"), () => {
  console.log(`Server is running on http://localhost:${app.get("port")}`);
});

How should I structure my Express.js application?​

Structuring an Express.js application depends on the complexity of the project. For small applications, a simple structure with a few files might suffice, but larger applications require a more organized approach.

Basic Structure:

my-express-app/
├── app.js # Entry point of the application
├── package.json # Project metadata and dependencies
└── node_modules/ # Installed dependencies

MVC Structure (Model-View-Controller):

my-express-app/
├── app.js
├── package.json
├── node_modules/
├── models/ # Database models
├── views/ # Template files
├── controllers/ # Route handlers
├── routes/ # Application routes
├── public/ # Static files (CSS, JavaScript, images)
└── config/ # Configuration files (e.g., database setup)

Example:

  • app.js:
const express = require("express");
const app = express();
const userRoutes = require("./routes/userRoutes");

app.use("/users", userRoutes);

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});
  • routes/userRoutes.js:
const express = require("express");
const router = express.Router();
const userController = require("../controllers/userController");

router.get("/", userController.getAllUsers);
router.post("/", userController.createUser);

module.exports = router;
  • controllers/userController.js:
exports.getAllUsers = (req, res) => {
  res.send("Retrieve all users");
};

exports.createUser = (req, res) => {
  res.send("Create a new user");
};

How to allow CORS in Express.js? Explain with an example.​

CORS (Cross-Origin Resource Sharing) is a mechanism that allows restricted resources on a web page to be requested from another domain. In Express.js, you can enable CORS by using the cors middleware.

Example of Enabling CORS:

  • Install the cors package:
npm install cors
  • Use the cors middleware in your Express app:
const express = require("express");
const cors = require("cors");
const app = express();

app.use(cors());

app.get("/data", (req, res) => {
  res.json({ message: "CORS is enabled for this route" });
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

Configuring CORS:

You can configure CORS to allow specific origins, methods, and headers.

app.use(
  cors({
    origin: "http://example.com",
    methods: ["GET", "POST"],
    allowedHeaders: ["Content-Type", "Authorization"],
  }),
);

How to enable debugging in an Express.js app?​

Debugging in an Express.js app can be enabled using the debug module, which allows you to output debugging information to the console.

Steps to Enable Debugging:

  • Install the debug module:
npm install debug
  • Require and Use the debug Module in Your Code:
const debug = require("debug")("app");
const express = require("express");
const app = express();

app.get("/", (req, res) => {
  debug("Handling request for root route");
  res.send("Hello World");
});

const PORT = 3000;
app.listen(PORT, () => {
  debug(`Server is running on http://localhost:${PORT}`);
});
  • Set the Debug Environment Variable:
    To see the debug output, you need to set the DEBUG environment variable before running your app.
DEBUG=app node app.js

This will show all debug logs with the app namespace.

Explain error handling in Express.js using an example.​

Error handling in Express.js is typically done using middleware functions. An error-handling middleware has 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("Internal Server Error");
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

In this example, if an error occurs in any route, it is caught by the error-handling middleware, which logs the error stack and sends a 500 response to the client.

What is the use of next in Express.js?​

In Express.js, next is a function that is passed as an argument to middleware functions. It is used to pass control to the next middleware function in the stack. If next is not called, the request-response cycle will be left hanging and the client will not receive a response.

Example of Using next:

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

app.use((req, res, next) => {
  console.log("Middleware 1");
  next();
});

app.use((req, res, next) => {
  console.log("Middleware 2");
  res.send("Hello from Middleware 2");
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

In this example, the first middleware logs a message and then calls next() to pass control to the next middleware. The second middleware sends a response to the client.

How to redirect 404 errors to a page in Express.js?​

To handle 404 errors (i.e., when a route is not found) in Express.js, you can create a middleware function that captures all requests that do not match any route and then sends a 404 response or redirects to a specific page.

Example of Redirecting 404 Errors:

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

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

// Middleware to handle 404 errors
app.use((req, res, next) => {
  res.status(404).send("Sorry, page not found!");
});

// Alternatively, you can redirect to a custom 404 page
app.use((req, res, next) => {
  res.status(404).redirect("/404.html");
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

In this example, if the user navigates to a route that does not exist, the middleware will catch it and send a 404 response or redirect to a custom 404 page.