Object-Oriented Programming in Node.js

Object-oriented programming (OOP) is a programming paradigm that revolves around the concept of objects. These objects encapsulate data and behavior, making them the fundamental building blocks of an OOP system. Node.js, being a versatile runtime environment for JavaScript, also allows developers to leverage OOP principles to build scalable and maintainable applications. In this blog post, we'll explore how OOP concepts can be applied in Node.js development, along with practical examples.

Classes and Objects

At the core of OOP are classes and objects. A class is a blueprint for creating objects and defining their properties (attributes) and methods (functions). In Node.js, you can define classes using the class keyword:

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    return `Hello, my name is ${this.name} and I'm ${this.age} years old.`;
  }
}

const person1 = new Person('Alice', 30);
console.log(person1.greet());

Inheritance

Inheritance allows one class to inherit properties and methods from another class. This promotes code reusability and helps in creating a hierarchy of classes. In Node.js, you can achieve inheritance using the extends keyword:

class Student extends Person {
  constructor(name, age, grade) {
    super(name, age);
    this.grade = grade;
  }

  study() {
    return `${this.name} is studying hard to get good grades.`;
  }
}

const student1 = new Student('Bob', 20, 'A');
console.log(student1.study());

Encapsulation

Encapsulation is the bundling of data (attributes) and methods that operate on the data into a single unit (class). This helps in controlling access to the data, ensuring that it's accessed and modified in a controlled manner. In Node.js, you can achieve encapsulation by defining private and public class members:

class Car {
  #speed = 0; // Private speed attribute

  accelerate() {
    this.#speed += 10;
    console.log(`Accelerating to ${this.#speed} km/h`);
  }

  getSpeed() {
    return this.#speed;
  }
}

const car1 = new Car();
car1.accelerate();
console.log(`Current speed: ${car1.getSpeed()} km/h`);

Polymorphism

class Shape {
  area() {
    throw new Error('Method area() must be implemented');
  }
}

class Circle extends Shape {
  constructor(radius) {
    super();
    this.radius = radius;
  }

  area() {
    return Math.PI * this.radius * this.radius;
  }
}

class Rectangle extends Shape {
  constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
  }

  area() {
    return this.width * this.height;
  }
}

const shapes = [new Circle(5), new Rectangle(5, 10)];
shapes.forEach(shape => console.log(`Area: ${shape.area()}`));

Conclusion

Node.js allows you to leverage OOP principles to create well-structured and maintainable code. By understanding and applying concepts like classes, inheritance, encapsulation, and polymorphism, you can build robust and scalable applications in Node.js.