JavaScript Notes

Encapsulation in JavaScript – Private Fields, Getters, Setters & Data Protection

Learn encapsulation in JavaScript with private class fields, getters, setters, closures, and real-world examples. Protect your data with ES2022 OOP techniques.

Encapsulation means bundling data (properties) and the methods that operate on that data together, while restricting direct access to the internal state. It prevents outside code from accidentally or maliciously corrupting an object's data.

Think of it as a capsule — the data is safely enclosed inside. You can only interact with it through the provided interface (methods), not directly.

📊 Encapsulation Diagram

Example

┌─────────────────────────────────────────────┐ │ BankAccount Object │ │ │ │ ┌─────────────────────────────────────┐ │ │ │ PRIVATE (hidden) │ │ │ │ #balance = 1000 │ │ │ │ #owner = "Riya" │ │ │ │ #validateAmount() │ │ │ └──────────────┬──────────────────────┘ │ │ │ controlled access │ │ ┌──────────────▼──────────────────────┐ │ │ │ PUBLIC (exposed) │ │ │ │ deposit(amount) │ │ │ │ withdraw(amount) │ │ │ │ get balance() │ │ │ └─────────────────────────────────────┘ │ └─────────────────────────────────────────────┘ ▲ │ Outside code can ONLY use public interface │ Cannot touch #balance directly

💻 Example 1 — Private Fields with Getters and Setters

Example

class BankAccount { #balance; // private — cannot be accessed from outside #owner; // private constructor(owner, initialBalance) { this.#owner = owner; this.#balance = initialBalance; } deposit(amount) { if (amount <= 0) throw new Error("Deposit must be positive"); this.#balance += amount; return this; // enable method chaining } withdraw(amount) { if (amount <= 0) throw new Error("Amount must be positive"); if (amount > this.#balance) throw new Error("Insufficient funds"); this.#balance -= amount; return this; } // Getter — read like a property, not a method get balance() { return this.#balance; } get owner() { return this.#owner; } toString() { return `Account[${this.#owner}]: ₹${this.#balance}`; } } const account = new BankAccount("Riya", 5000); account.deposit(1000).deposit(500).withdraw(200); // method chaining console.log(account.balance); console.log(account.owner); console.log(account.toString());

Output

6300
Riya
Account[Riya]: ₹6300

💻 Example 2 — Setter with Validation

js example

class Temperature {
  #celsius;

  constructor(celsius) {
    this.celsius = celsius;   // ← triggers setter with validation
  }

  get celsius()   { return this.#celsius; }
  get fahrenheit() { return this.#celsius * 9/5 + 32; }
  get kelvin()     { return this.#celsius + 273.15; }

  set celsius(value) {
    if (value < -273.15) throw new Error("Below absolute zero!");
    this.#celsius = value;
  }
}

const temp = new Temperature(100);
console.log(temp.celsius);      // getter
console.log(temp.fahrenheit);   // computed getter
console.log(temp.kelvin);       // computed getter

temp.celsius = 0;
console.log(temp.fahrenheit);

// temp.celsius = -300;   // throws Error: Below absolute zero!

Output

💻 Example 3 — Encapsulation via Closures (Pre-ES2022)

Example

Output

1300
[ { type: 'deposit', amount: 500 }, { type: 'withdraw', amount: 200 } ]
undefined

💻 Example 4 — Private Methods for Internal Logic

Example

class PasswordManager { #passwords = new Map(); // Private methods — internal helpers #hash(password) { // simplified — real code uses bcrypt return `hashed_${password.split("").reverse().join("")}`; } #isStrong(password) { return password.length >= 8 && /[A-Z]/.test(password) && /\d/.test(password); } // Public interface save(service, password) { if (!this.#isStrong(password)) { throw new Error("Password too weak. Needs 8+ chars, uppercase, and number."); } this.#passwords.set(service, this.#hash(password)); console.log(`✅ Password saved for ${service}`); } verify(service, password) { const stored = this.#passwords.get(service); return stored === this.#hash(password); } } const pm = new PasswordManager(); pm.save("gmail", "SecurePass1"); console.log(pm.verify("gmail", "SecurePass1")); console.log(pm.verify("gmail", "wrongpass"));

Output

✅ Password saved for gmail
true
false

📋 Encapsulation Techniques Comparison

Technique	Privacy Level	ES Version	Notes
`#privateField`	True private	ES2022	Best approach — enforced by engine
`_convention`	Soft private	All	Just a naming convention — anyone can access
Closure	True private	All	No class needed — factory function pattern
`WeakMap`	True private	ES6	Stores private data outside the class
`Object.freeze()`	Immutable	ES5	Prevents adding/changing properties

⚠️ Common Mistakes

❌ Mistake 1 — Using `_` Underscore Is NOT True Privacy

js example

class Account {
  constructor(balance) {
    this._balance = balance;  // ← underscore is JUST a convention
  }
}

const a = new Account(1000);
a._balance = -999999;  // ← still works! No actual protection
console.log(a._balance);

Output

-999999

❌ Mistake 2 — Returning a Reference to Private Array

Example

class TodoList { #items = ["Buy milk", "Learn JS"]; getItems() { return this.#items; // ← dangerous! caller gets direct reference } } const list = new TodoList(); const items = list.getItems(); items.push("HACKED!"); // modifies the private array! console.log(list.getItems().length);

Output

Fix: Return a copy: return [...this.#items] or return this.#items.slice()

❌ Mistake 3 — Forgetting Setter Means the Field Is Read-Only

js example

class Config {
  #apiKey = "abc123";
  get apiKey() { return this.#apiKey; }
  // No setter defined
}

const c = new Config();
c.apiKey = "newKey";   // silently ignored in non-strict, error in strict
console.log(c.apiKey); // still "abc123"

Output

abc123

🎯 Key Takeaways

Encapsulation = bundle data + behavior and restrict direct access
Use #privateField (ES2022) for true privacy enforced by the JavaScript engine
Always provide getters for read access and setters with validation for write access
Return copies of internal arrays/objects from public methods — never expose internal references
Closures are a valid encapsulation pattern for factory functions without classes
The _underscore convention signals "internal" but provides zero actual protection
Encapsulation makes objects robust, predictable, and easier to maintain

❓ Interview Questions

Q1. What is encapsulation in JavaScript? > Encapsulation means bundling data (properties) with the methods that operate on that data inside an object, and restricting direct access to the internal state. Only controlled interfaces (public methods) can interact with private data.

Q2. How do you make a field truly private in JavaScript? > Use the # prefix — e.g., #balance = 0. This is a private class field enforced by the JavaScript engine (ES2022+). It is not accessible outside the class via any mechanism.

Q3. What is the difference between _name and #name? > _name is just a naming convention — the underscore signals "internal" but the field is still fully public. Anyone can read or write obj._name. #name is truly private — the engine blocks all outside access.

Q4. What are getters and setters used for in encapsulation? > Getters provide controlled read access to private data. Setters add validation logic before allowing writes. Together they create a safe interface: callers use obj.balance naturally, but the access goes through your validation code.

Q5. How did encapsulation work before private class fields? > Via closures in factory functions. Data declared in the outer function scope is naturally private to the returned object. For example, let balance = 0 inside a factory is accessible only through the returned deposit() and getBalance() methods.

Q6. Why is it bad to return a direct reference to a private array? > The caller gets a reference to the actual array, not a copy. Any mutation they do (push, splice, direct assignment) changes the private internal state, breaking encapsulation. Always return [...this.#array] or this.#array.slice().

Q7. Can you access private fields using JavaScript reflection or Proxy? > No. Private class fields (#) are a language-level feature — not properties on the object at all. Object.keys(), JSON.stringify(), Reflect, and Proxy cannot see them. Only the class body itself can access them.

Q8. What is the relationship between encapsulation and data integrity? > Encapsulation enforces data integrity by ensuring all mutations go through controlled methods. Instead of account.balance = -500 (invalid direct write), callers must use account.withdraw(500), which validates the amount and checks for sufficient funds first.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Encapsulation in JavaScript – Private Fields, Getters, Setters & Data Protection.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this JavaScript Master Course topic.

Search Terms

javascript-complete-guide, javascript master course, javascript, complete, guide, oop, encapsulation, encapsulation in javascript – private fields, getters, setters & data protection

Continue learning this concept

Oop In JavascriptAbstraction in JavaScript OOP – Hide Complexity, Expose SimplicityLearn abstraction in JavaScript OOP with class examples, private fields, real-world analogies, common mistakes, and interview Q&A. beginner-friendly tutorial.Oop In JavascriptJavaScript Classes Tutorial – ES6 Class Syntax, Inheritance & MoreMaster JavaScript ES6 classes with constructors, methods, static members, inheritance, private fields, and real-world examples. beginner-friendly JS OOP tutorial.Oop In JavascriptJavaScript Constructor Functions – new Keyword, Prototype & OOP PatternsUnderstand JavaScript constructor functions with the new keyword, prototype methods, object creation, comparison with ES6 classes, and interview-ready Q&A.Oop In JavascriptJavaScript Inheritance – extends, super, and Prototype-Based InheritanceMaster JavaScript inheritance with ES6 extends, super keyword, method overriding, prototype chain, multi-level inheritance, and interview-ready Q&A examples.Oop In JavascriptObject-Oriented Programming in JavaScript – OOP Concepts Complete GuideComplete guide to OOP in JavaScript: classes, objects, the 4 pillars (encapsulation, inheritance, abstraction, polymorphism), prototype chain, and interview Q&A.Oop In JavascriptJavaScript OOP Projects – Build Real-World Apps with Classes & OOPPractice JavaScript OOP with 3 real-world projects: Shopping Cart, Library System, and Student Grade Manager. Apply classes, inheritance, encapsulation, and polymorphism.

PreviousJavaScript Constructor Functions – new Keyword, Prototype & OOP Patterns NextJavaScript Inheritance – extends, super, and Prototype-Based Inheritance

📊 Encapsulation Diagram

💻 Example 1 — Private Fields with Getters and Setters

💻 Example 2 — Setter with Validation

💻 Example 3 — Encapsulation via Closures (Pre-ES2022)

💻 Example 4 — Private Methods for Internal Logic

📋 Encapsulation Techniques Comparison

⚠️ Common Mistakes

❌ Mistake 1 — Using _ Underscore Is NOT True Privacy

❌ Mistake 2 — Returning a Reference to Private Array

❌ Mistake 3 — Forgetting Setter Means the Field Is Read-Only

🎯 Key Takeaways

❓ Interview Questions

Continue learning this concept

📊 Encapsulation Diagram

💻 Example 1 — Private Fields with Getters and Setters

💻 Example 2 — Setter with Validation

💻 Example 3 — Encapsulation via Closures (Pre-ES2022)

💻 Example 4 — Private Methods for Internal Logic

📋 Encapsulation Techniques Comparison

⚠️ Common Mistakes

❌ Mistake 1 — Using _ Underscore Is NOT True Privacy

❌ Mistake 2 — Returning a Reference to Private Array

❌ Mistake 3 — Forgetting Setter Means the Field Is Read-Only

🎯 Key Takeaways

❓ Interview Questions

Continue learning this concept

❌ Mistake 1 — Using `_` Underscore Is NOT True Privacy

❌ Mistake 1 — Using `_` Underscore Is NOT True Privacy