Omor Faruk
To write a detailed blog on JavaScript's Object-Oriented Programming (OOP) concepts and prototypes, we'll go through first-class functions, first-class instances, inheritance, polymorphism, encapsulation, and abstraction, explaining both class-based and prototype-based approaches.
JavaScript is unique in that it can support both class-based OOP (introduced in ES6) and prototype-based OOP (the original way JavaScript handled OOP). This blog will dive into key OOP concepts like first-class functions, first-class instances, inheritance, polymorphism, encapsulation, and abstraction using both approaches.
1. First-Class Functions
In JavaScript, functions are first-class citizens. This means that functions can be:
- Assigned to variables
- Passed as arguments
- Returned from other functions
Absolutely! Let's break down the blog post to cover both first-class functions and first-class instances using both functional and class-based approaches in JavaScript. This will provide a clear understanding of these concepts in the context of Object-Oriented Programming (OOP).
Functional Approach
Example: First-Class Functions
// Assigning a function to a variable
const greet = function(name) {
return `Hello, ${name}!`;
};
// Passing a function as an argument
function logGreeting(fn, name) {
console.log(fn(name));
}
// Returning a function
function createMultiplier(multiplier) {
return function(number) {
return number * multiplier;
};
}
logGreeting(greet, "John"); // Output: Hello, John!
const double = createMultiplier(2);
console.log(double(5)); // Output: 10
Explanation:
- Functions can be stored, passed, and returned like any other value, showcasing first-class functions.
Class-Based Approach
Although functions are first-class citizens, we can also create classes that mimic similar behavior.
Example: First-Class Functions in a Class Context
class Greeter {
constructor(name) {
this.name = name;
}
greet() {
return `Hello, ${this.name}!`;
}
}
// Logging greeting
class Logger {
static logGreeting(greeter) {
console.log(greeter.greet());
}
}
// Using classes to demonstrate first-class functions
const greeter = new Greeter("John");
Logger.logGreeting(greeter); // Output: Hello, John!
Explanation:
- The
Greeterclass demonstrates a first-class function-like behavior by encapsulating thegreetmethod, which can be passed to other functions (likelogGreeting).
2. First-Class Instances
Instances of objects or classes can also be treated as first-class citizens. They can be assigned to variables, passed as arguments, and stored in collections.
Like functions, instances of objects or classes can also be treated as first-class citizens. They can be:
- Assigned to variables
- Passed as arguments
- Returned from functions
- Stored in collections like arrays
Functional Approach
Example: First-Class Instances
function Car(make, model) {
this.make = make;
this.model = model;
this.startEngine = function() {
console.log(`${this.make} ${this.model} engine started.`);
};
}
const myCar = new Car("Toyota", "Corolla");
const yourCar = new Car("Tesla", "Model 3");
// Passing instance as an argument
function showCarDetails(car) {
console.log(`Car: ${car.make} ${car.model}`);
}
showCarDetails(myCar); // Output: Car: Toyota Corolla
Explanation:
- Here,
myCarandyourCarare instances of theCarfunction constructor. They can be passed to functions and stored in variables.
Class-Based Approach
Example: First-Class Instances in Class Context
class Car {
constructor(make, model) {
this.make = make;
this.model = model;
}
startEngine() {
console.log(`${this.make} ${this.model} engine started.`);
}
}
const myCar = new Car("Toyota", "Corolla");
const yourCar = new Car("Tesla", "Model 3");
// Passing instance as an argument
function showCarDetails(car) {
console.log(`Car: ${car.make} ${car.model}`);
}
showCarDetails(myCar); // Output: Car: Toyota Corolla
Explanation:
- In this example,
myCarandyourCarare instances of theCarclass, and just like the functional approach, they can be passed to functions and manipulated.
3. Inheritance
Class-Based Inheritance allows you to create a new class that inherits properties and methods from an existing class using the extends keyword.
Class-Based Example:
class Animal {
constructor(name) {
this.name = name;
}
speak() {
console.log(`${this.name} makes a sound.`);
}
}
class Dog extends Animal {
speak() {
console.log(`${this.name} barks.`);
}
}
const myDog = new Dog("Buddy");
myDog.speak(); // Output: Buddy barks.
Prototype-Based Example:
function Animal(name) {
this.name = name;
}
Animal.prototype.speak = function() {
console.log(`${this.name} makes a sound.`);
};
function Dog(name) {
Animal.call(this, name); // Inherit properties
}
Dog.prototype = Object.create(Animal.prototype); // Inherit methods
Dog.prototype.constructor = Dog;
Dog.prototype.speak = function() {
console.log(`${this.name} barks.`);
};
const myDog = new Dog("Buddy");
myDog.speak(); // Output: Buddy barks.
Explanation:
-
Class-based inheritance uses
extendsto inherit from a parent class, while prototype-based inheritance usesObject.createto link objects.
4. Polymorphism
Polymorphism allows different objects to define their own versions of the same method, which can be called on objects of a parent type.
Class-Based Example:
class Animal {
speak() {
console.log("Animal makes a sound.");
}
}
class Dog extends Animal {
speak() {
console.log("Dog barks.");
}
}
class Cat extends Animal {
speak() {
console.log("Cat meows.");
}
}
const animals = [new Dog(), new Cat()];
animals.forEach(animal => animal.speak());
// Output:
// Dog barks.
// Cat meows.
Prototype-Based Example:
function Animal() {}
Animal.prototype.speak = function() {
console.log("Animal makes a sound.");
};
function Dog() {}
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.speak = function() {
console.log("Dog barks.");
};
function Cat() {}
Cat.prototype = Object.create(Animal.prototype);
Cat.prototype.speak = function() {
console.log("Cat meows.");
};
const animals = [new Dog(), new Cat()];
animals.forEach(animal => animal.speak());
// Output:
// Dog barks.
// Cat meows.
Explanation:
-
Polymorphism allows both class-based and prototype-based objects to define their own version of the
speakmethod while still inheriting from a parent type.
5. Encapsulation
Encapsulation involves hiding the internal details of an object and exposing only what is necessary. In JavaScript, we achieve this by using private fields (with #) in class-based OOP or closures in prototype-based OOP.
Class-Based Example:
class Car {
#engineStarted = false;
startEngine() {
this.#engineStarted = true;
console.log("Engine started.");
}
drive() {
if (this.#engineStarted) {
console.log("Car is driving.");
} else {
console.log("Start the engine first.");
}
}
}
const car = new Car();
car.drive(); // Output: Start the engine first.
car.startEngine(); // Output: Engine started.
car.drive(); // Output: Car is driving.
Prototype-Based Example:
function Car() {
let engineStarted = false; // Private via closure
this.startEngine = function() {
engineStarted = true;
console.log("Engine started.");
};
this.drive = function() {
if (engineStarted) {
console.log("Car is driving.");
} else {
console.log("Start the engine first.");
}
};
}
const car = new Car();
car.drive(); // Output: Start the engine first.
car.startEngine(); // Output: Engine started.
car.drive(); // Output: Car is driving.
Explanation:
- Class-based encapsulation uses private fields (introduced in ES6) to hide data, while prototype-based encapsulation achieves privacy through closures.
6. Abstraction
Abstraction hides complex logic and only exposes necessary details. It can be achieved by abstracting away internal details and exposing essential methods.
Class-Based Example:
class Robot {
#batteryLevel = 100;
recharge() {
this.#batteryLevel = 100;
console.log("Battery fully charged.");
}
performTask() {
if (this.#batteryLevel > 0) {
this.#batteryLevel -= 10;
console.log("Task performed. Battery level:", this.#batteryLevel);
} else {
console.log("Battery low. Recharge needed.");
}
}
}
const robo = new Robot();
robo.performTask(); // Output: Task performed. Battery level: 90
robo.recharge(); // Output: Battery fully charged.
Prototype-Based Example:
function Robot() {
let batteryLevel = 100; // Private via closure
this.recharge = function() {
batteryLevel = 100;
console.log("Battery fully charged.");
};
this.performTask = function() {
if (batteryLevel > 0) {
batteryLevel -= 10;
console.log("Task performed. Battery level:", batteryLevel);
} else {
console.log("Battery low. Recharge needed.");
}
};
}
const robo = new Robot();
robo.performTask(); // Output: Task performed. Battery level: 90
robo.recharge(); // Output: Battery fully charged.
Explanation:
- Both approaches encapsulate the complexity of managing battery levels, exposing only the necessary methods for interaction.
Conclusion
Understanding the differences and similarities between class-based and prototype-based OOP in JavaScript enhances your programming skills. First-class functions and instances, inheritance, polymorphism, encapsulation, and abstraction are fundamental concepts that you can leverage to write cleaner and more maintainable code.
While the modern class-based syntax (introduced in ES6) is more readable and familiar to developers coming from other OOP languages, the prototype-based approach is more fundamental to JavaScript's underlying behavior.
This blog demonstrates how core OOP concepts — first-class functions, first-class instances, inheritance, polymorphism, encapsulation, and abstraction — can be achieved in both paradigms. Whether you're using classes or prototypes, JavaScript offers robust mechanisms to implement OOP in a flexible and powerful way.
