Приватные поля в JavaScript: синтаксис #

Проблема с подчёркиваниями

Долгое время в JavaScript просто не было приватных полей. Вместо них использовали договорённость: к имени свойства добавляли подчёркивание и надеялись, что остальные разработчики не полезут туда, куда не надо:

class Counter {
    constructor() {
        this._count = 0;
    }
    increment() {
        this._count++;
    }
}

const c = new Counter();
c.increment();
console.log(c._count);   // 1 - ничто этому не мешает
c._count = 999;          // как и этому
console.log(c._count);   // 999

_count выглядит приватным, но на самом деле это не так. Любой вызывающий код может его прочитать, перезаписать или удалить. Подчёркивание - это всего лишь вежливая табличка на двери; сама дверь нараспашку.

Современный JavaScript решил эту проблему - появились настоящие приватные поля, которые помечаются символом #.

Символ # делает поле приватным

Добавьте префикс # к имени поля в объявлении и в каждом месте, где вы к нему обращаетесь:

class Counter {
    #count = 0;

    increment() {
        this.#count++;
    }

    get value() {
        return this.#count;
    }
}

const c = new Counter();
c.increment();
c.increment();
console.log(c.value);    // 2

Внутри класса this.#count работает как обычное поле. А вот снаружи его просто не существует:

class Counter {
    #count = 0;
    increment() { this.#count++; }
}

const c = new Counter();
// console.log(c.#count);   // SyntaxError на этапе парсинга
console.log(c["#count"]);   // undefined - это не то же самое свойство

# - это буквально часть имени поля. Это не модификатор вроде ключевого слова private из других языков, а специальный символ, по которому парсер ищет отдельный защищённый слот у объекта. Именно поэтому ошибка вылезает ещё на этапе парсинга - до того, как код вообще запустится.

Приватные методы и геттеры

Приватными можно делать не только поля. Методы, геттеры и сеттеры тоже прекрасно работают с префиксом #:

class BankAccount {
    #balance = 0;

    deposit(amount) {
        this.#assertPositive(amount);
        this.#balance += amount;
    }

    get balance() {
        return this.#balance;
    }

    #assertPositive(n) {
        if (n <= 0) throw new Error("Amount must be positive");
    }
}

const acc = new BankAccount();
acc.deposit(100);
console.log(acc.balance);    // 100
// acc.#assertPositive(5);   // SyntaxError

#assertPositive - это внутренний помощник. В публичное API он не входит, и если сделать его по-настоящему приватным, никто не вызовет его извне по ошибке. А раз от него никто не зависит, вы спокойно сможете переименовать или удалить его позже.

Приватные статические поля и методы

Статические члены тоже можно делать приватными. Префикс # работает точно так же:

class IdGenerator {
    static #nextId = 1;

    static generate() {
        return IdGenerator.#nextId++;
    }
}

console.log(IdGenerator.generate());   // 1
console.log(IdGenerator.generate());   // 2
// console.log(IdGenerator.#nextId);   // SyntaxError

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

Наследники их не видят

Здесь часто спотыкаются те, кто пришёл из Java или C#. В JavaScript приватные поля принадлежат классу, а не экземпляру. Подкласс не может залезть в приватные поля родителя:

class Animal {
    #name;
    constructor(name) {
        this.#name = name;
    }
    describe() {
        return `животное по имени ${this.#name}`;
    }
}

class Dog extends Animal {
    bark() {
        // return `${this.#name} says woof`;   // SyntaxError
        return `${this.describe()} говорит гав`;
    }
}

console.log(new Dog("Rex").bark());

В JavaScript нет модификатора protected. Если подклассу нужен доступ к данным, родитель должен предоставить метод, геттер или (что встречается реже) обычное, непривaтное поле. Это сделано намеренно: приватное - значит действительно приватное, и наследование не проделывает в нём дырок.

Проверка приватного поля через in

Иногда нужно убедиться, что объект действительно принадлежит вашему классу - это так называемый brand check. Внутри класса оператор in умеет работать с именами приватных полей:

class Wallet {
    #balance = 0;

    static isWallet(obj) {
        return #balance in obj;
    }
}

const real = new Wallet();
const fake = { balance: 100 };

console.log(Wallet.isWallet(real));   // true
console.log(Wallet.isWallet(fake));   // false

Поскольку создавать объекты с #balance умеет только Wallet, проверка #balance in obj - надёжный способ убедиться, что obj действительно экземпляр Wallet. В некоторых пограничных случаях это быстрее и безопаснее, чем instanceof: приватные поля невозможно подделать снаружи.

Типичная ловушка: у обычных объектов приватных полей нет

Приватные поля существуют только у экземпляров, созданных конструктором класса. Если попытаться обратиться к такому полю у объекта, созданного без new, получим ошибку:

class Point {
    #x;
    constructor(x) { this.#x = x; }
    getX() { return this.#x; }
}

const p = new Point(5);
console.log(p.getX());       // 5

const fake = {};
// Point.prototype.getX.call(fake);   // TypeError: Cannot read private member #x

Вызов метода с this, который не является экземпляром Point, выбросит ошибку прямо в рантайме. Именно так работает brand check, о котором шла речь выше: приватные поля привязаны к конкретному классу, в котором они объявлены, а не к произвольному объекту с подходящей формой.

Когда использовать #

По умолчанию делайте поля приватными всегда, когда состояние или вспомогательный метод не входит в публичный API класса. Почему это удобно:

• Свобода рефакторинга. Внешний код просто не может зацепиться за то, что ему не видно.
• Настоящая инкапсуляция в JavaScript. Никаких случайных чтений, записей или удалений снаружи.
• Чистый автокомплит. Редактор не подсовывает приватные члены тем, кто пользуется классом извне.

Публичные свойства оставляйте для того, что действительно является частью интерфейса. Если нужен доступ к приватному полю только на чтение - заведите геттер (get name()). А от соглашения с подчёркиванием (_field) пора отказаться: это был костыль на время, пока в языке не было настоящей приватности. Теперь она есть.

class Temperature {
    #celsius;

    constructor(celsius) {
        this.#celsius = celsius;
    }

    get celsius() { return this.#celsius; }
    get fahrenheit() { return this.#celsius * 9 / 5 + 32; }
}

const t = new Temperature(20);
console.log(t.celsius);      // 20
console.log(t.fahrenheit);   // 68
// t.celsius = 100;          // TypeError: нет сеттера - только для чтения

#celsius - это скрытое хранилище, а celsius и fahrenheit - представления только для чтения. Снаружи внутреннее состояние не испортить, а сам класс в любой момент может поменять способ хранения значения.

Дальше: прототипы

Классы в JavaScript - это по большей части синтаксический сахар над системой прототипов, более старой и фундаментальной моделью, на которой язык, собственно, и построен. Разобравшись с прототипами, вы поймёте, почему this ведёт себя именно так, как на самом деле работает наследование и что скрывается за extends у класса. Об этом - на следующей странице.