Node.js and Express.js: Key Differences and Code Walkthrough

Node.js and Express.js are two widely used tools that frequently come to mind when starting a backend development project. Even though they are closely connected, each has a unique function and goal. We will examine the main distinctions between Node.js and Express.js in this blog post and each framework’s advantages and disadvantages, with useful code examples to help clarify the use cases.

Table of Contents

What is Node.js?

With Node.js, developers can execute JavaScript code on the server side in an open-source, cross-platform runtime environment. With an event-driven, non-blocking I/O model, it is lightweight, efficient, and based on the V8 JavaScript engine found in Chrome. For creating scalable network applications and real-time applications, Node.js is especially well-suited.

Key Features of Node.js:

Event-Driven Architecture: Efficiently handles asynchronous operations.
Single Programming Language: Uses JavaScript for both client-side and server-side code.
Scalability: Handles multiple concurrent connections with ease.
Rich Ecosystem: The npm (Node Package Manager) provides a vast library of modules.

What is Express.js?

Express.js is a feature-rich Node.js web application framework that is simple to use and adaptable, offering a wide range of capabilities for developing web and mobile applications. It streamlines the development process by offering a collection of tools and middleware to manage routine operations like routing, sessions, and more.

Key Features of Express.js:

Simplified Routing: Easy to define routes for your web applications.
Middleware Support: Middleware functions can be used to handle various tasks.
Template Engines: Supports various template engines for dynamic HTML generation.
Extensibility: This can be extended with plugins and modules to fit specific needs.

Node.js vs. Express.js: Key Differences

Scope and Purpose:

Node.js: A runtime environment for executing JavaScript server-side.
Express.js: A web application framework built on top of Node.js.

Complexity and Learning Curve:

Node.js: Requires a solid understanding of JavaScript and asynchronous programming.
Express.js: Easier to learn if you’re familiar with Node.js, with built-in features to speed up development.

Development Speed:

Node.js: Requires more boilerplate code for basic tasks.
Express.js: Accelerates development with built-in functionalities.

Flexibility:

Node.js: Complete control over the application architecture.
Express.js: Structured yet flexible approach with middleware and plugins.

Code Examples

Basic Node.js Server

Here’s a simple example of a basic HTTP server using Node.js:

const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello, World!\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

In this example, we create an HTTP server that listens on port 3000 and responds with “Hello, World!” to any incoming request. While this is straightforward, setting up more complex routes and handling various types of requests would require more code.

Basic Express.js Server

Now, let’s see how the same functionality can be achieved using Express.js:

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

const port = 3000;

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

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

With Express.js, the code is more concise and readable. The ‘app.get()' method defines a route for the root URL ‘(/)’, and ‘res.send()' sends the response. Express.js simplifies tasks such as routing and response handling, making the development process faster and more intuitive.

Routing in Express JS

Express.js routing makes things easier to use and simplifies implementation. We can directly specify route names and related functions using Express’s built-in functions. We can also specify the type of request—for example, GET or POST—by indicating its type. This simplified method simplifies the development process, increasing output and lowering complexity.

// Requiring module
const express = require('express');
const app = express();

// Handling '/' request
app.get('/', (req, res) => {
    res.send('<h2>Hello from Express.js server!!</h2>');
});

// Handling '/about' request
app.get('/about', (req,res) => {
    res.send('<h2>GeeksforGeeks- Express.js</h2>');
});

// Server setup
app.listen(8080, () => {
    console.log('server listening on port 8080');
});

Routing in Node JS

Node.js does not come with built-in routing. Rather, each incoming request’s method and URL must be manually examined by developers to decide how to handle and reply to it. This means that the application code must implement the routing logic; usually, this can be done with conditional statements or by using frameworks like Express.js, which provide more structured routing capabilities. Through scrutiny of the method and URL of every request, developers can dynamically customize responses according to the particular needs of the application.

// Requiring the module
const http = require('http');

// Creating server object
const server = http.createServer((req, res) => {
    const url = req.url;
    
    if(url === '/') {
        res.write('<html>');
        res.write(
'<head><title>GeeksforGeeks</title><head>');
        res.write(
'<body><h2>Hello from Node.js server!!</h2></body>');
        res.write('</html>');
        return res.end();
    }
    
    if(url === '/about') {
        res.write('<html>');
        res.write(
'<head><title>GeeksforGeeks</title><head>');
        res.write(
'<body><h2>GeeksforGeeks- Node.js</h2></body>');
        res.write('</html>');
        return res.end();
    }
});

// Server setup
server.listen(3000, () => {
    console.log("Server listening on port 3000")
});

Choosing the Right Tool

The choice between Node.js and Express.js depends on your project requirements:

Use Node.js if you require a fast, lightweight runtime to run JavaScript on the server, especially for microservices and real-time applications.
Use Express.js to build web applications and APIs quickly and efficiently, leveraging built-in features and middleware support.

Conclusion

Backend development, Node.js and Express.js are handy tools. While Express.js expands on Node.js’s basic runtime environment, it is still possible to develop web applications and APIs more quickly. Selecting the appropriate tool for your project and improving your server-side development skills can be achieved by being aware of their advantages and weaknesses. Whether you’re creating a new application or expanding an old one, knowing these technologies inside and out will enable you to create scalable and effective solutions.

Learn more about the Node js and Express js