Статические и приватные поля

Обычные методы живут на прототипе и достаются каждому объекту. Но часть поведения относится не к отдельному экземпляру, а ко всему виду сразу: общая константа, счётчик созданных объектов, проверка строки ещё до того, как объект появился. Слово static кладёт поле или метод на сам класс.

class Temperature {
  static toFahrenheit(c) {
    return c * 9 / 5 + 32;
  }
}
console.log(Temperature.toFahrenheit(100));
console.log(typeof new Temperature().toFahrenheit);

Вторая строка вывода — главное, что стоит запомнить: у экземпляра статического метода нет. Статика не спускается вниз, к объектам, зато передаётся вбок — подклассы её наследуют.

Статическое поле тоже одно на весь класс, а не по копии на объект. Отсюда классический приём — счётчик, который увеличивается в конструкторе.

class User {
  static count = 0;
  constructor(name) { this.name = name; User.count += 1; }
}
new User("Аня");
new User("Борис");
console.log(User.count);

У конструктора одно имя и один набор аргументов. Как только объект можно собрать несколькими способами — из массива, из строки, из рублей, — конструктор начинает обрастать проверками «а что мне передали на этот раз». Статическая фабрика убирает эту развилку: это обычный статический метод, который сам зовёт new и возвращает готовый объект.

class Money {
  constructor(cents) { this.cents = cents; }
  static fromRubles(rubles) { return new Money(rubles * 100); }
  static zero() { return new Money(0); }
}
console.log(Money.fromRubles(2.5).cents);
console.log(Money.zero().cents);

Выигрыш не только в аккуратности, но и в читаемости на месте вызова. Money.fromRubles(2.5) понятен без документации, а new Money(2.5) заставляет открывать конструктор и гадать, рубли там или копейки.

class Base {
  static create() { return new this(); }
}
class Child extends Base {}
console.log(Child.create() instanceof Child);
console.log(Base.create() instanceof Child);

Поле, имя которого начинается с #, существует только внутри тела класса. Снаружи к нему не подобраться никак: ни точкой, ни через квадратные скобки, ни перебором ключей, ни через JSON.stringify. Объявить такое поле нужно прямо в теле класса — просто присвоить this.#value в конструкторе, не объявив поле, не получится.

class Counter {
  #value = 0;
  inc() { this.#value += 1; return this; }
  get value() { return this.#value; }
}
const c = new Counter().inc().inc();
console.log(c.value);
console.log(Object.keys(c));

Приватность здесь синтаксическая, а не по договорённости. Если написать c.#value за пределами класса, движок откажется разбирать сам файл: ошибка прилетит ещё до запуска, а не в момент вызова.

# — часть имени поля, а не модификатор доступа. Поэтому #name и name спокойно уживаются в одном классе как два разных поля, а пробел после решётки — синтаксическая ошибка.

Каждое публичное поле — это обещание. Пока balance торчит наружу, любой участок программы может записать туда минус, строку или undefined, и класс перестаёт отвечать за собственную корректность. Спрятав поле, вы оставляете снаружи только те действия, которые не способны привести объект в невозможное состояние.

class Account {
  #balance = 0;
  deposit(sum) { if (sum > 0) this.#balance += sum; }
  get balance() { return this.#balance; }
}
const a = new Account();
a.deposit(100); a.deposit(-50);
console.log(a.balance);

Второй выигрыш — свобода переписывать. Внутреннее устройство не входит в публичный договор: пока deposit и геттер balance ведут себя как раньше, можно хранить сумму хоть в копейках, хоть в отдельном объекте — снаружи никто ничего не заметит.

До появления # приватность была вопросом вежливости: поле называли _token, и это значило «сюда не лезь». Беда в том, что язык о таком соглашении не знает — поле остаётся обычным и ведёт себя как обычное.

class Legacy {
  constructor() { this._token = "abc"; }
}
const l = new Legacy();
l._token = "взломан";
console.log(l._token);
console.log(JSON.stringify(l));

Решётка работает и со статикой: static #instances = 0 — общий на класс счётчик, к которому не дотянуться извне. Комбинация «приватная статика плюс статическая фабрика» даёт классический одиночка.

class Config {
  static #instance = null;
  static get() {
    if (Config.#instance === null) Config.#instance = new Config();
    return Config.#instance;
  }
}
console.log(Config.get() === Config.get());