Question 32

Question

Can you explain how to use Symbols as private properties in ES6 classes?

Answer

Symbols are perfect for creating private properties within ES6 classes. Here's a breakdown of how they work:

The Problem with Traditional Private Properties:

• No True Privacy: In plain JavaScript, methods like _property (using an underscore prefix) aren't truly private. They can be accessed and modified from outside the class if someone really tries.

• Limited Encapsulation: This lack of strong privacy makes it harder to maintain code integrity and enforce intended behavior.

Symbols to the Rescue!

• Unique Identifiers: Symbols create unique, non-enumerable keys that are ideal for private properties. Since they're not part of the standard object enumeration, they're hidden from casual inspection.

• Symbol() Function: Use Symbol() to generate a new symbol.

Example Implementation:

class BankAccount {
  constructor(initialBalance) {
    this[Symbol('balance')] = initialBalance; // Using Symbol as the key
  }

  deposit(amount) {
    this[Symbol('balance')] += amount;
  }

  withdraw(amount) {
    if (this[Symbol('balance')] >= amount) {
      this[Symbol('balance')] -= amount;
      return true; // Success
    } else {
      return false; // Insufficient funds
    }
  }

  getBalance() {
    return this[Symbol('balance')]; 
  }
}

// Create an account
const myAccount = new BankAccount(100);

// Deposit and withdraw
myAccount.deposit(50);
console.log(myAccount.getBalance()); // Accessing the balance directly is harder

// Can't access directly through `myAccount.balance` or similar

Explanation:

1. Symbol as Key: We use Symbol('balance') to create a unique symbol key. This becomes our private property identifier.

2. Setting and Accessing Values: Inside the class constructor, we assign an initial balance using this symbol key. When we need to get or modify the balance later (e.g., in deposit, withdraw, or getBalance), we access it through the same symbol key.

Benefits:

• Strong Privacy: Symbols make it much harder for external code to directly manipulate private properties, protecting your class's internal state.

• Improved Encapsulation: Private properties reinforce the principles of encapsulation, making your classes more robust and maintainable.