OOP in Node.js with TypeScript

Mastering Modular Node.js: The Power of OOP with TypeScript Classes

Byalexrusin

If your Node.js projects are growing into difficult-to-manage monoliths, it’s time to embrace Object-Oriented Programming (OOP). OOP is the secret to building scalable, modular, and maintainable applications.

In this article, we’ll explore how to leverage classes, the fundamental building block of OOP, using the power of TypeScript to structure your Node.js code like a true professional.

🚀 Complete JavaScript Guide (Beginner + Advanced)

🚀 NodeJS – The Complete Guide (MVC, REST APIs, GraphQL, Deno)

1. Classes: Blueprints for Scalability

At its core, OOP uses classes to define reusable blueprints for objects. These objects hold their own data (state) and functions (behaviors).

The JavaScript Prototype Reality Check

It’s crucial to remember that while JavaScript introduced the class keyword in ES6, it remains a prototypical language. The class syntax is simply “syntactic sugar” implemented on top of JavaScript’s native prototype system.

Creating a Class:

You declare a class using the class keyword followed by the name.

TypeScript

class Car {
  // Class body: properties and methods will be defined here
}

// Creating an instance (an object) from the blueprint
const myCar = new Car();

2. Constructors and Properties

The constructor is a special method that runs automatically every time a new instance of the class is created. It is primarily used to initialize the object’s properties (its internal data).

Defining Properties

Properties hold the unique data for each instance. Let’s add a constructor to initialize a make property:

TypeScript

class Car {
  // 1. Declare the property and its type
  public make: string;

  constructor(make: string) {
    // 2. Assign the passed parameter to the property
    this.make = make;
    console.log(`Constructor called for ${this.make}`);
  }
}

const toyota = new Car("Toyota"); // Output: Constructor called for Toyota
console.log(toyota.make);         // Output: Toyota

TypeScript’s Parameter Property Shortcut

Declaring properties and then manually assigning them in the constructor can be tedious. TypeScript provides an elegant shortcut: include a visibility modifier (public, private, or protected) directly in the constructor parameter list.

TypeScript

class Car {
  // The 'public' modifier handles the declaration AND assignment!
  constructor(public make: string, public productionDate: Date = new Date()) {
    console.log(`${this.make} was built on ${this.productionDate.toLocaleDateString()}`);
  }
}

const ford = new Car("Ford");
// No need to declare 'make' and 'productionDate' at the top!

3. Methods: Defining Object Behavior

Methods are functions defined within a class that define the object’s behaviors. They typically operate using the class’s internal properties, which is why OOP is so powerful: it co-locates related data and behavior.

You access properties and other methods within the class using the this keyword.

TypeScript

class Car {
  constructor(public make: string) {}

  // A class method
  drive(speed: number) {
    // Accessing the internal property 'make' using 'this'
    console.log(`${this.make} is driving at ${speed} mph!`);
  }
}

const honda = new Car("Honda");
honda.drive(65); // Output: Honda is driving at 65 mph!

4. Leveraging TypeScript for Type Safety

One of the greatest benefits of using TypeScript with classes is that the class itself can be used as a type, ensuring that any object passed to a function adheres to the expected structure.

TypeScript

class Driver {
  // Use the 'Car' class as a type definition for the 'car' parameter
  drive(car: Car) {
    console.log("Driver is starting the car...");
    car.drive(70);
  }
}

const alex = new Driver();
alex.drive(honda);
/* Output:
Driver is starting the car...
Honda is driving at 70 mph!
*/

5. Method Style: Regular vs. Arrow Functions

In complex scenarios, the this context in JavaScript can become unbound (or rebound to something unexpected), causing errors. To combat this, you can define class methods as arrow functions.

The this Binding Problem (The reason for Arrow Methods):

TypeScript

class Car {
  constructor(public make: string) {}

  // Regular method (added to prototype)
  drive() {
    console.log(`${this.make} is driving.`);
  }
}

const myCar = new Car("Toyota");

// Create a plain object and assign the method to it
const externalDriver = {
  name: "Jon",
  startDrive: myCar.drive, // Method is copied/referenced without the original 'this' context
};

externalDriver.startDrive(); // Output: undefined is driving. (Broke the 'this' context)

The Arrow Function Solution:

TypeScript

class Car {
  constructor(public make: string) {}

  // Arrow function method (defined on EACH instance)
  drive = () => {
    console.log(`${this.make} is driving.`);
  };
}

const myCarFixed = new Car("Toyota");

const externalDriverFixed = {
  name: "Jon",
  startDrive: myCarFixed.drive, // 'this' is now permanently bound to the Car instance
};

externalDriverFixed.startDrive(); // Output: Toyota is driving. (Fixed!)

Best Practice Note on Performance

While arrow methods fix the this issue, they come at a cost: performance and memory.

  • Regular Methods: Added to the class prototype, meaning all instances share a single function definition. (Saves memory)
  • Arrow Methods: Defined on each instance, creating a new function for every object. (Wastes memory if used excessively)

Use arrow methods only when you need to ensure the this context is bound (e.g., in event handlers or callbacks). In all other cases, use regular methods to take advantage of JavaScript’s memory-saving prototype system.

Conclusion

By integrating TypeScript classes into your Node.js development, you gain immediate advantages in modularity, type safety, and architectural clarity. These are the foundations of truly professional and maintainable applications.

Share this article

Similar Posts