Encapsulation

The Final Frontier: Private Fields

Before ES2022, JavaScript lacked true encapsulation, relying on naming conventions like total _underscores. With Private Fields, JS now provides language-level "Hard Privacy" that cannot be bypassed by external code.

Hard Privacy with the Hash (#) Syntax

Private fields, prefixed with #, are not merely hidden; they are unreachable from outside the class body. This ensures that internal implementation details can change without breaking consumer codeâ€”the fundamental promise of Object-Oriented Programming.

JAVASCRIPT

// --- ES2022 Hard Privacy (#) ---
class SecureVault {
    // 1. Declaration is mandatory
    #secretKey;
    #accessCount = 0;

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

    // 2. Private Method
    #incrementAccess() {
        this.#accessCount++;
        console.log(`Access #${this.#accessCount}`);
    }

    unlock(inputKey) {
        if (inputKey === this.#secretKey) {
            this.#incrementAccess();
            return 'Sensors Activated';
        }
        return 'Access Denied';
    }
}

const vault = new SecureVault('BLUE-BIRD');
console.log(vault.unlock('BLUE-BIRD'));
// console.log(vault.#secretKey); // âŒ Uncaught SyntaxError

Legacy Privacy: The WeakMap Pattern

Before the # syntax, developers usedWeakMap to store private data. This pattern associates private state with a specific object instance without preventing garbage collection, ensuring memory efficiency even for large sets of objects.

JAVASCRIPT

// --- The WeakMap Pattern (Legacy "Hard" Privacy) ---
const _internalState = new WeakMap();

class UserAccount {
    constructor(userId) {
        _internalState.set(this, {
            userId: userId,
            loginTime: Date.now()
        });
    }

    getDetails() {
        const state = _internalState.get(this);
        return `User: ${state.userId} logged at ${state.loginTime}`;
    }
}

// Memory Efficient: When the UserAccount instance is garbage 
// collected, the WeakMap entry is also removed automatically.

Encapsulated State Machines

The most powerful use case for private fields isInternal State Management. By making the status field private, you force all updates to go through a valid transition method, preventing objects from entering impossible states.

JAVASCRIPT

// --- Private State Machine Pattern ---
class Transaction {
    #state = 'PENDING'; // Truly encapsulated state

    #transitions = {
        'PENDING': ['AUTHORIZED', 'CANCELLED'],
        'AUTHORIZED': ['CAPTURED', 'REFUNDED'],
    };

    process(nextState) {
        const allowed = this.#transitions[this.#state];
        if (allowed?.includes(nextState)) {
            this.#state = nextState;
            console.log(`Status: ${this.#state}`);
        } else {
            throw new Error(`Invalid move: ${this.#state} -&gt; ${nextState}`);
        }
    }
}

const tx = new Transaction();
tx.process('AUTHORIZED');
// tx.#state = 'CAPTURED'; // âŒ Cannot bypass the process() logic

ðŸ’¡ Design Tip: Always default to private. Only make a field public when you are certain it needs to be part of the object's external API. Minimal surface area equals fewer bugs.

Senior Architect's Checklist:

âœ… Hard Privacy: Use # for data that should NEVER be touched by external consumers.
âœ… Mandatory Declaration: Unlike public fields, private fields MUST be declared in the class body.
âŒ Inheritance: Remember that private fields are NOT visible to subclasses (even super cannot see them).
âœ… Performance: Modern engines (V8) can optimize private field access because the list of properties is fixed at compile-time.
âœ… Refactoring: Use privacy to hide the "messy" internals of your API, keeping the public interface clean.

What's Next?

You've mastered the complex world of JS Objects and Privacy. Now, let's step into the world of Asynchronous JavaScriptâ€”where we handle operations that don't happen instantly.

Next: Async Patterns & Promises â†’