How to achieve oop in nodejs

In Node.js, the primary approach to implementing Object-Oriented Programming (OOP) is through JavaScript's class and prototype inheritance features. Here are several steps to implement OOP:

1. Defining Classes

With ES6, the introduction of the class keyword provides a more intuitive way to define classes. Classes serve as blueprints for objects, allowing the definition of properties and methods.

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

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

2. Creating Object Instances

Use the new keyword to instantiate objects from a class.

javascript
const person1 = new Person('Alice', 30);
person1.greet(); // Output: Hello, my name is Alice and I am 30 years old.

3. Inheritance

A class can inherit properties and methods from another class using the extends keyword.

javascript
class Employee extends Person {
  constructor(name, age, jobTitle) {
    super(name, age); // Call the parent class's constructor
    this.jobTitle = jobTitle;
  }

  work() {
    console.log(`${this.name} is working as a ${this.jobTitle}.`);
  }
}

const employee1 = new Employee('Bob', 25, 'Software Developer');
employee1.greet();   // Output: Hello, my name is Bob and I am 25 years old.
employee1.work();    // Output: Bob is working as a Software Developer.

4. Encapsulation

Encapsulation is a core concept in OOP, meaning that the state and behavior of an object are contained internally, exposing only limited interfaces for external interaction.

javascript
class BankAccount {
  #balance; // Private property, marked with #

  constructor(initialBalance) {
    this.#balance = initialBalance;
  }

  deposit(amount) {
    if (amount > 0) {
      this.#balance += amount;
    }
  }

  withdraw(amount) {
    if (amount <= this.#balance) {
      this.#balance -= amount;
    }
  }

  getBalance() {
    return this.#balance;
  }
}

const account = new BankAccount(1000);
account.deposit(500);
console.log(account.getBalance()); // Output: 1500

In this example, #balance is a private property that cannot be accessed directly from outside the class; it can only be manipulated through the class's methods.

5. Polymorphism

Polymorphism means that subclasses can define a method with the same name as in the parent class but with different behavior.

javascript
class Animal {
  speak() {
    console.log('Animal speaks');
  }
}

class Dog extends Animal {
  speak() {
    console.log('Woof woof');
  }
}

const animal = new Animal();
const dog = new Dog();

animal.speak(); // Output: Animal speaks
dog.speak();    // Output: Woof woof

In this example, the Dog class overrides the speak method of the Animal class, demonstrating polymorphism.

By following these steps, we can implement the fundamental concepts of OOP in Node.js, including class definition, inheritance, encapsulation, and polymorphism. These principles help organize and modularize code, making it easier to understand and maintain.