Node.js Examples for Web Development

In the ever-evolving landscape of web development, Node.js has emerged as a powerhouse, enabling developers to build scalable and efficient server-side applications. Its event-driven architecture and non-blocking I/O make it a preferred choice for building real-time applications. 

In this blog post, we will explore various Node.js examples as per LIBETG and frameworks that play a crucial role in modern web development.

Express.js: The Foundation of Node.js Web Applications

Express.js is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications. Its simplicity and versatility make it a favorite among developers for building APIs and single-page applications. Here’s a basic example of setting up an Express.js server:

const express = require(‘express’);

const app = express();

const port = 3000;

app.get(‘/’, (req, res) => {

  res.send(‘Hello, Express.js!’);


app.listen(port, () => {

  console.log(`Server listening at http://localhost:${port}`);


This code creates a simple server that listens on port 3000 and responds with “Hello, Express.js!” when accessed. Real-time Communication Made Easy is a powerful library that enables real-time, bidirectional and event-based communication. It’s often used in applications that require instant updates, such as chat applications and online gaming. Setting up a basic server involves integrating it with an Express.js server:

const express = require(‘express’);

const http = require(‘http’);

const socketIO = require(‘’);

const app = express();

const server = http.createServer(app);

const io = socketIO(server);

io.on(‘connection’, (socket) => {

  console.log(‘A user connected’);


  socket.on(‘disconnect’, () => {

    console.log(‘User disconnected’);



server.listen(3000, () => {

  console.log(‘ server listening on port 3000’);


This code establishes a WebSocket connection and logs when a user connects or disconnects.

Hap: Crafting Web Servers with Confidence

Hap is a rich framework for building web servers with Node.js. It provides a solid foundation for crafting HTTP servers, complete with built-in support for routing, middleware, and plugins. Let’s look at a basic Hap example:

const Hapi = require(‘@hapi/hapi’);

const init = async () => {

  const server = Hapi.server({

    port: 3000,

    host: ‘localhost’



    method: ‘GET’,

    path: ‘/’,

    handler: (request, h) => {

      return ‘Hello, Hap!’;



  await server.start();

  console.log(`Hap server running at: ${}`);



This example creates a server using Hap and defines a simple route that responds with “Hello, Hap!”.

NestJS: Building Scalable and Maintainable Server-side Applications

NestJS is a full-featured framework for building scalable and maintainable server-side applications. It combines elements from Object-Oriented Programming, Functional Programming, and Reactive Programming to create a powerful development experience. Here’s a basic example of a NestJS controller:

import { Controller, Get } from ‘@nestjs/common’;


export class AppController {


  getHello(): string {

    return ‘Hello, NestJS!’;



NestJS leverages TypeScript for a strongly-typed and statically-typed development experience.

Mocha and Chai: Testing the Waters of Node.js Applications

Testing is an integral part of web development, and Mocha combined with Chai provides an excellent testing framework for Node.js applications. Mocha is a feature-rich test framework, while Chai is an assertion library that works seamlessly with Mocha. Here’s a simple Mocha and Chai test example:

const { expect } = require(‘chai’);

describe(‘Array’, () => {

  it(‘should return -1 when the value is not present’, () => {

    expect([1, 2, 3].indexOf(4)).to.equal(-1);



This test checks whether the indexOf method returns -1 when the value is not present in the array.

Sequelize: Managing Relational Databases with Ease

Sequelize is a promise-based ORM (Object-Relational Mapping) for Node.js, which supports various relational databases such as MySQL, PostgreSQL, and SQLite. It simplifies database interactions and provides a convenient way to model and query data. Here’s a quick example of defining a Sequelize model:

const { Sequelize, DataTypes } = require(‘sequelize’);

const sequelize = new Sequelize(‘database’, ‘username’, ‘password’, {

  host: ‘localhost’,

  dialect: ‘mysql’


const User = sequelize.define(‘User’, {

  firstName: {

    type: DataTypes.STRING,

    allowNull: false


  lastName: {

    type: DataTypes.STRING



(async () => {

  await sequelize.sync();

  const user = await User.create({ firstName: ‘John’, lastName: ‘Doe’ });



This example defines a User model and inserts a new user into the database.

Passport: Authentication Made Simple

Passport is an authentication middleware for Node.js that is easy to integrate into Express.js applications. It supports various authentication strategies, including local authentication, OAuth, and OpenID. Here’s a basic example of setting up Passport with local authentication

const passport = require(‘passport’);

const LocalStrategy = require(‘passport-local’).Strategy;

passport.use(new LocalStrategy(

  (username, password, done) => {

    // Authenticate user here

    // Example: Find user in the database and check password

    if (username === ‘user’ && password === ‘password’) {

      return done(null, { id: 1, username: ‘user’ });

    } else {

      return done(null, false, { message: ‘Incorrect username or password’ });




// Integrate with Express.js

const express = require(‘express’);

const app = express();

app.use(require(‘express-session’)({ secret: ‘secret’, resave: false, saveUninitialized: false }));



  passport.authenticate(‘local’, { successRedirect: ‘/’, failureRedirect: ‘/login’, failureFlash: true })


app.listen(3000, () => {

  console.log(‘Passport authentication example listening on port 3000’);


This example sets up local authentication with Passport, allowing users to log in with a username and password.

End Note

Node.js has become a cornerstone in web development, and the examples mentioned above showcase its versatility and power. Whether you’re building a real-time chat application, a scalable web server, or implementing authentication, Node.js and its associated frameworks and libraries provide the tools you need to succeed in the dynamic world of web development. By mastering these tools, developers can create robust and efficient applications that meet the demands of today’s users and businesses.

Related Articles

Leave a Reply

Back to top button