Encapsulation in JavaScript

Key Concepts

Encapsulation is a fundamental concept in object-oriented programming (OOP) that involves bundling the data (properties) and methods (functions) that operate on the data into a single unit, known as a class. The key concepts related to encapsulation include:

• Data Hiding
• Access Modifiers
• Getter and Setter Methods

Data Hiding

Data hiding is the practice of keeping the internal state of an object private, so it can only be accessed and modified through the object's methods. This prevents direct manipulation of the object's data from outside the class.

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

const person = new Person('John', 30);
console.log(person._name); // Accessing private data directly
    

Access Modifiers

Access modifiers control the visibility of properties and methods within a class. In JavaScript, there are no explicit access modifiers like in other languages (e.g., public, private, protected). However, properties and methods can be made private using closures or the new ES6 private field syntax.

class Person {
    #name; // Private field
    constructor(name, age) {
        this.#name = name;
        this._age = age;
    }
}

const person = new Person('John', 30);
console.log(person.#name); // Error: Private field '#name' is not accessible
    

Getter and Setter Methods

Getter and setter methods provide controlled access to the object's properties. Getters retrieve the property values, while setters modify them. This allows for validation and additional logic when accessing or modifying the properties.

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

    get name() {
        return this._name;
    }

    set name(newName) {
        if (typeof newName === 'string') {
            this._name = newName;
        } else {
            console.error('Name must be a string');
        }
    }

    get age() {
        return this._age;
    }

    set age(newAge) {
        if (newAge > 0) {
            this._age = newAge;
        } else {
            console.error('Age must be a positive number');
        }
    }
}

const person = new Person('John', 30);
console.log(person.name); // Output: John
person.name = 'Jane';
console.log(person.name); // Output: Jane
person.age = -5; // Error: Age must be a positive number
    

Examples and Analogies

Imagine encapsulation as a bank vault:

• Data Hiding: Think of the bank vault as a secure place where valuables (data) are stored. Only authorized personnel (methods) can access the contents.
• Access Modifiers: Think of the different levels of security (access modifiers) that determine who can enter the vault. In JavaScript, we use closures or private fields to simulate these levels of access.
• Getter and Setter Methods: Think of the vault's access points (getter and setter methods) that allow authorized personnel to retrieve or deposit valuables. These methods ensure that the valuables are handled correctly and securely.

By understanding and applying encapsulation, you can create more secure and maintainable code, ensuring that the internal state of your objects is protected and accessed only through controlled methods.