In a JavaScript class body, what does declaring a field as #count = 0 give you that the older convention of naming it _count does not?

## What the `#` actually declares A leading `#` does not create a property called `"#count"`. It declares a **private name**, a distinct kind of key that has no string form at all. Each instance that runs the declaration gets an internal slot for that name, and the only way to reach the slot is to write the `#count` token in source code that sits inside the class body which declared it. ```js class Counter { #count = 0; increment() { return ++this.#count; } } const c = new Counter(); c['#count']; // undefined — there is no string key by that name ``` Because there is no string key, there is no computed access either: `obj[someExpression]` can never produce a private name. ## Two different failures It is worth keeping these apart, because interviewers probe the difference: - **Undeclared name — SyntaxError, before anything runs.** If a piece of code writes `#count` and no enclosing class body declares `#count`, the script fails to parse: *Private field '#count' must be declared in an enclosing class*. This includes a subclass body trying to touch a parent's private field. - **Declared name, wrong object — TypeError, at run time.** Inside the declaring class body the name is legal, but the object must actually carry the field. `other.#count` where `other` is a plain object literal throws *TypeError: Cannot read private member*. The safe test is the brand check `#count in other`, which yields a boolean. ## What an underscore gives you Nothing the engine knows about. `this._count = 0` creates a normal own property, writable and enumerable like any other. It is documentation aimed at a reader who is willing to cooperate. The moment a consumer needs behaviour you did not expose, `obj._count = 99` works, and now your internal representation is part of your public contract in practice even though it never was on paper. That is the concrete reason the language grew real privacy: not secrecy, but the freedom to change internals later. ## Invisibility to reflection and serialization Private fields are skipped by every enumeration and reflection path: ```js class Account { #balance = 100; owner = 'ada'; } const a = new Account(); Object.keys(a); // [ 'owner' ] Object.getOwnPropertyNames(a); // [ 'owner' ] Reflect.ownKeys(a); // [ 'owner' ] JSON.stringify(a); // '{"owner":"ada"}' { ...a }; // { owner: 'ada' } ``` This cuts both ways. It is exactly what you want for an internal cache or a mutation counter. It is a trap if the field is real state you expect to survive a round trip: `JSON.stringify` silently drops it, so a class holding its data privately needs an explicit `toJSON()` method, and `structuredClone` will not carry it either. ## Private methods and accessors The same `#` prefix works for methods and accessors, and they are brand-checked the same way: ```js class Order { #items = []; #total() { return this.#items.length; } get #isEmpty() { return this.#total() === 0; } add(x) { this.#items.push(x); return this.#isEmpty; } } ``` A private method is not a property of the instance and not a property of the prototype in any observable way — you cannot find it, patch it, or call it from outside. ## Where the boundary really sits Privacy here is a **language** boundary, not a security boundary. Code in the same file that sits inside the class body has full access, which is the intended "friend" escape hatch. Developer tools can still display private fields in an inspector. Treat `#` as the mechanism that stops accidental coupling and lets you refactor internals freely — not as a place to hide a secret from someone who controls the runtime. ## The one interoperability trap worth knowing If you wrap an instance in a `Proxy`, method calls arrive with the proxy as the receiver. The proxy is a different object and carries no private slots, so the first `this.#field` inside the method throws a TypeError. Underscore-named properties are just forwarded and keep working. If a class must be proxy-wrappable, that is a genuine argument for keeping its state elsewhere.