プライベート要素

メモ: MDN では、「プライベートプロパティ」という用語の使用は避けています。JavaScript のプロパティには文字列またはシンボルのキーがあり、writable、enumerable、configurable などの属性がありますが、プライベート要素にはこれらの属性は存在しません。プライベート要素は、おなじみのドット表記でアクセスできますが、プロキシーを行ったり、列挙したり、削除したり、 Object メソッドを使用して対話したりすることはできません。

class ClassWithPrivate {
 #privateField;
 #privateFieldWithInitializer = 42;
 #privateMethod() {
 // ...
 }
 static #privateStaticField;
 static #privateStaticFieldWithInitializer = 42;
 static #privateStaticMethod() {
 // ...
 }
}

class ClassWithPrivateField {
 #privateField;
 constructor() {
 delete this.#privateField; // Syntax error
 this.#undeclaredField = 42; // Syntax error
 }
}
const instance = new ClassWithPrivateField();
instance.#privateField; // Syntax error

メモ: Chrome コンソールで実行するコードは、クラス外からプライベート要素にアクセスすることができます。これは JavaScript の構文制限を開発者ツール限定で緩和したものです。

class C {
 #x;
 static getX(obj) {
 return obj.#x;
 }
}
console.log(C.getX(new C())); // undefined
console.log(C.getX({})); // TypeError: Cannot read private member #x from an object whose class did not declare it

class C {
 #x;
 constructor(x) {
 this.#x = x;
 }
 static getX(obj) {
 if (#x in obj) return obj.#x;
 return "obj must be an instance of C";
 }
}
console.log(C.getX(new C("foo"))); // "foo"
console.log(C.getX(new C(0.196))); // 0.196
console.log(C.getX(new C(new Date()))); // the current date and time
console.log(C.getX({})); // "obj must be an instance of C"

class ClassWithPrivateField {
 #privateField;
 constructor() {
 this.#privateField = 42;
 }
}
class Subclass extends ClassWithPrivateField {
 #subPrivateField;
 constructor() {
 super();
 this.#subPrivateField = 23;
 }
}
new Subclass(); // 開発者ツールでは Subclass {#privateField: 42, #subPrivateField: 23} と表示

メモ: 基底クラス ClassWithPrivateField の #privateField は ClassWithPrivateField のプライベートメンバーであり、派生クラス Subclass からはアクセスできません。

class Stamper extends class {
 // コンストラクターが指定されたオブジェクトを返す基底クラス
 constructor(obj) {
 return obj;
 }
} {
 // この宣言は、基底クラスのコンストラクターが返すオブジェクトに
 // プライベートフィールドを「刻印」する
 #stamp = 42;
 static getStamp(obj) {
 return obj.#stamp;
 }
}
const obj = {};
new Stamper(obj);
// `Stamper` は `Base` を呼び出して `obj` を返す。次に
// `Stamper` は `obj` に `#stamp` を定義する
console.log(obj); // 一部の開発者ツールでは {#stamp: 42} と表示
console.log(Stamper.getStamp(obj)); // 42
console.log(obj instanceof Stamper); // false
// プライベート要素に 2 度刻印することはできません。
new Stamper(obj); // Error: Initializing an object twice is an error with private fields

警告: これはとても混乱を招きかねないことです。一般的に、コンストラクターから任意のものを返すのは避けるようにしましょう。特に this に関係のないものを返すのは避けるようにしましょう。

class ClassWithPrivateStaticField {
 static #privateStaticField = 42;
 static publicStaticMethod() {
 return ClassWithPrivateStaticField.#privateStaticField;
 }
}
console.log(ClassWithPrivateStaticField.publicStaticMethod()); // 42

class ClassWithPrivateStaticField {
 static #privateStaticField = 42;
 static publicStaticMethod() {
 return this.#privateStaticField;
 }
}
class Subclass extends ClassWithPrivateStaticField {}
Subclass.publicStaticMethod(); // TypeError: Cannot read private member #privateStaticField from an object whose class did not declare it

class ClassWithPrivateStaticField {
 static #privateStaticField = 42;
 static publicStaticMethod() {
 // super を呼び出しても、 `this` は Subclass を参照している
 return this.#privateStaticField;
 }
}
class Subclass extends ClassWithPrivateStaticField {
 static callSuperMethod() {
 return super.publicStaticMethod();
 }
}
Subclass.callSuperMethod(); // TypeError: Cannot read private member #privateStaticField from an object whose class did not declare it

class ClassWithPrivateMethod {
 #privateMethod() {
 return 42;
 }
 publicMethod() {
 return this.#privateMethod();
 }
}
const instance = new ClassWithPrivateMethod();
console.log(instance.publicMethod()); // 42

class ClassWithPrivateAccessor {
 #message;
 get #decoratedMessage() {
 return `🎬${this.#message}🛑`;
 }
 set #decoratedMessage(msg) {
 this.#message = msg;
 }
 constructor() {
 this.#decoratedMessage = "hello world";
 console.log(this.#decoratedMessage);
 }
}
new ClassWithPrivateAccessor(); // 🎬hello world🛑

class C {
 #method() {}
 static getMethod(x) {
 return x.#method;
 }
}
console.log(C.getMethod(new C())); // [Function: #method]
console.log(C.getMethod(C.prototype)); // TypeError: Receiver must be an instance of class C

class ClassWithPrivateStaticMethod {
 static #privateStaticMethod() {
 return 42;
 }
 static publicStaticMethod() {
 return ClassWithPrivateStaticMethod.#privateStaticMethod();
 }
}
console.log(ClassWithPrivateStaticMethod.publicStaticMethod()); // 42

class ClassWithPrivateStaticMethod {
 static #privateStaticMethod() {
 return 42;
 }
 static publicStaticMethod() {
 return this.#privateStaticMethod();
 }
}
class Subclass extends ClassWithPrivateStaticMethod {}
console.log(Subclass.publicStaticMethod()); // TypeError: Cannot read private member #privateStaticMethod from an object whose class did not declare it

class PrivateConstructor {
 static #isInternalConstructing = false;
 constructor() {
 if (!PrivateConstructor.#isInternalConstructing) {
 throw new TypeError("PrivateConstructor は構築できません");
 }
 PrivateConstructor.#isInternalConstructing = false;
 // More initialization logic
 }
 static create() {
 PrivateConstructor.#isInternalConstructing = true;
 const instance = new PrivateConstructor();
 return instance;
 }
}
new PrivateConstructor(); // TypeError: PrivateConstructor は構築できません
PrivateConstructor.create(); // PrivateConstructor {}

Help improve MDN

This page was last modified on ⁨2025年9月13日⁩ by MDN contributors.