Private Methods and Variables in JavaScript

Encapsulation is a concept derived from object-oriented programming (OOP) that consists of hiding and protecting the internal details of a class

In other words, it is about protecting direct access to data and exposing only what is necessary for other parts of the program to interact with that class.

Private Properties

In JavaScript, ES2022 introduced the private fields syntax. To do this, the property name is prefixed with #.

Properties that use this prefix are only accessible within the class in which they are defined (they cannot be accessed or modified from outside the class).

class Person {
    #name;

    constructor(name) {
        this.#name = name;
    }

    getName() {
        return this.#name;
    }
}

const person1 = new Person("Juan");
// Correct access through a public method
console.log(person1.getName()); // "Juan"

// This will cause an error: "Cannot read private member"
console.log(person1.#name); // Error

Private Methods

Methods can also be private. Like properties, they are defined with the # prefix:

class User {
    #secretKey;

    constructor(key) {
        this.#secretKey = key;
    }

    #showKey() {
        console.log(`The secret key is: ${this.#secretKey}`);
    }

    authenticate() {
        this.#showKey(); // Valid call from within the class
    }
}

const user1 = new User("12345");
user1.authenticate(); // The secret key is: 12345
// This will cause an error: "Cannot read private member"
// user1.#showKey(); // Error

Getters and Setters

Encapsulation fits very well with the use of getter and setter methods.

class Person {
    #age;

    constructor(age) {
        this.#age = age;
    }

    get age() {
        return this.#age;
    }

    set age(newAge) {
        if (newAge > 0) {
            this.#age = newAge;
        } else {
            console.log("Age must be positive.");
        }
    }
}

const person2 = new Person(25);
console.log(person2.age); // 25
person2.age = 30;         // Modifies age
console.log(person2.age); // 30
person2.age = -5;         // Age must be positive.

Simple Example of Encapsulation

Let’s look at a basic example of how data can be encapsulated within a class:

class BankAccount {
    // Private property (accessed only from the class)
    #balance;

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

    // Public method to get the balance
    getBalance() {
        return this.#balance;
    }

    // Public method to deposit money
    deposit(amount) {
        if (amount > 0) {
            this.#balance += amount;
        } else {
            console.log("The amount must be positive.");
        }
    }

    // Public method to withdraw money
    withdraw(amount) {
        if (amount <= this.#balance) {
            this.#balance -= amount;
        } else {
            console.log("Insufficient funds.");
        }
    }
}

const account1 = new BankAccount(1000);
console.log(account1.getBalance());  // 1000
account1.deposit(500);
console.log(account1.getBalance());  // 1500
account1.withdraw(200);
console.log(account1.getBalance());  // 1300