JavaScript Classes
A field starting with a hash is private and cannot be read from outside the class.
The underscore convention was only ever a hint; nothing enforced it.
A # field is genuinely inaccessible from outside.
Example
javascript
class Account {
#balance = 100;
getBalance() {
return this.#balance;
}
}
console.log(new Account().getBalance());The balance is readable through the method but not directly.
A name beginning with # is private to the class body.
Reading it from outside is a syntax error, not just a bad idea.
Methods can be private too.
Syntax
javascript
class Name {
#secret = value;
#privateMethod() {}
}The # is part of the name, not an operator.
Unlike the underscore convention, this cannot be worked around.
It does not appear in Object.keys either.
Example
javascript
class Account {
#balance = 100;
name = "current";
}
const account = new Account();
console.log(Object.keys(account).join(","));Only the public field is listed.
Expose exactly what you want, and nothing more.
Example
javascript
class Account {
#balance = 0;
deposit(amount) {
if (amount > 0) {
this.#balance += amount;
}
return this.#balance;
}
}
const account = new Account();
account.deposit(-50);
console.log(account.deposit(100));The negative deposit was refused and the balance stayed safe.
Helpers that are nobody else's business can be hidden too.
Example
javascript
class Order {
#price = 100;
#tax() {
return this.#price * 0.2;
}
total() {
return this.#price + this.#tax();
}
}
console.log(new Order().total());The output is 120, and #tax cannot be called from outside.
An underscore says please do not touch this, but nothing stops you.
You will still see it constantly in older code.
Example
javascript
class Account {
constructor() {
this._balance = 100;
}
}
const account = new Account();
account._balance = 999999;
console.log(account._balance);Nothing prevented the change, which is exactly the problem.
A child class cannot reach its parent's private fields.
That is the point: private means private to that class body.
Example
javascript
class Parent {
#secret = "hidden";
reveal() {
return this.#secret;
}
}
class Child extends Parent {}
console.log(new Child().reveal());The child can use the public method but not the field itself.
Complete Example
html
<!DOCTYPE html>
<html>
<head>
<title>JavaScript Private Fields</title>
</head>
<body>
<h1>Private Fields</h1>
<p id="out"></p>
<script>
class Account {
#balance = 0;
constructor(owner) {
this.owner = owner;
}
deposit(amount) {
if (amount <= 0) return this.#balance;
this.#balance += amount;
return this.#balance;
}
get balance() {
return this.#balance;
}
}
const account = new Account("Ada");
account.deposit(100);
account.deposit(-500);
document.getElementById("out").textContent =
account.owner + " has " + account.balance;
</script>
</body>
</html>Run the above example in the Try It Editor.
Try reaching in:
Add account.#balance = 999 and see the syntax error.
# name is private to the class body.Object.keys.Private fields turn encapsulation from a convention into a rule.
Exposing a method or a getter gives you control over how data is reached.
This is the modern replacement for the underscore prefix.