> For the complete documentation index, see [llms.txt](https://choubey.gitbook.io/javascript-interview-questions/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://choubey.gitbook.io/javascript-interview-questions/question-32.md).

# 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:**

```javascript
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.