Private Field JavaScript: Sintaks # untuk Privasi Class

Masalahnya dengan garis bawah

Selama bertahun-tahun, JavaScript tidak punya private field. Konvensinya adalah memberi awalan garis bawah pada sebuah property dan berharap semua orang menghormatinya:

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

const c = new Counter();
c.increment();
console.log(c._count);   // 1 - nothing stops this
c._count = 999;          // or this
console.log(c._count);   // 999

_count terlihat private, padahal tidak. Pemanggil mana pun bisa membacanya, menulisnya, atau menghapusnya. Garis bawah itu ibarat papan sopan di pintu; pintunya sendiri terbuka lebar.

JavaScript modern memperbaiki ini dengan private field sungguhan, yang ditandai dengan #.

# membuatnya private

Beri awalan # pada nama field di deklarasi dan di setiap tempat ia diakses:

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

Dari dalam class, this.#count berfungsi seperti biasa. Dari luar, ia tidak ada:

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

const c = new Counter();
// console.log(c.#count);   // SyntaxError at parse time
console.log(c["#count"]);   // undefined - not the same property

# benar-benar bagian dari nama field. Ia bukan kata kunci modifier seperti private di bahasa lain, melainkan tanda yang dipakai parser untuk mencari slot terpisah yang terlindungi di object itu. Karena itulah error-nya muncul saat parsing, bahkan sebelum kode dijalankan.

Private method dan getter

Bukan hanya field yang bisa ditandai private. Method, getter, dan setter semuanya menerima awalan #:

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 adalah helper internal. Ia bukan bagian dari API publik, jadi membuatnya benar-benar private berarti tidak ada yang tanpa sengaja memanggilnya dari luar, dan tidak ada yang bisa bergantung padanya, sehingga kamu tetap bebas mengganti namanya atau menghapusnya nanti.

Private static member

Static member juga bisa private. Beri awalan # dengan cara yang sama:

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

Static private tinggal di class itu sendiri, bukan di instance. Berguna untuk counter, cache, atau konfigurasi yang tidak boleh bocor keluar dari class.

Subclass tidak bisa melihatnya

Ini sering menjebak orang yang datang dari Java atau C#. Private field di JavaScript bersifat class-private, bukan instance-private. Subclass tidak bisa menjangkau private field milik induknya:

class Animal {
    #name;
    constructor(name) {
        this.#name = name;
    }
    describe() {
        return `an animal named ${this.#name}`;
    }
}

class Dog extends Animal {
    bark() {
        // return `${this.#name} says woof`;   // SyntaxError
        return `${this.describe()} says woof`;
    }
}

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

Tidak ada protected di JavaScript. Kalau subclass butuh datanya, class induk harus menyediakan method, getter, atau (lebih jarang) field yang tidak private. Desainnya disengaja: private benar-benar berarti private, dan pewarisan tidak membuat lubang di dalamnya.

Mengecek private field dengan in

Kadang kamu ingin memastikan sebuah object benar-benar milik class-mu, yang disebut brand check. Operator in bisa dipakai dengan nama private field di dalam class:

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

Karena hanya Wallet yang bisa membuat object dengan #balance, #balance in obj adalah tes yang andal bahwa obj adalah instance Wallet yang asli. Dalam beberapa kasus tepi, ini lebih cepat dan lebih aman daripada instanceof, karena private field tidak bisa dipalsukan dari luar.

Jebakan umum: object biasa tidak memilikinya

Private field tinggal di instance yang dibuat oleh constructor class. Kalau kamu mencoba memakainya pada object yang tidak dibuat dengan new, ia melempar error:

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

Memanggil method dengan this yang bukan Point akan melempar error saat runtime. Inilah mekanisme di balik brand check di atas: private field terikat ke class tertentu yang mendeklarasikannya, bukan ke object apa pun yang kebetulan terlihat cocok.

Kapan memakai #

Gunakan private field sebagai default setiap kali sebuah state atau helper bukan bagian dari API publik class. Alasannya:

• Bebas refactor. Pemanggil tidak bisa bergantung pada bagian internal yang memang tidak bisa mereka lihat.
• Enkapsulasi sungguhan. Tidak ada pembacaan, penulisan, atau penghapusan tak sengaja dari kode luar.
• Autocomplete lebih bersih. Editor tidak menyarankan member private ke pemanggil dari luar.

Pakai property publik saat sesuatu memang bagian dari antarmuka. Pakai getter (get name()) saat kamu ingin akses read-only ke private field. Tinggalkan konvensi garis bawah: itu dulu hanya akal-akalan untuk celah yang kini sudah diisi oleh bahasanya.

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: no setter - read-only

#celsius adalah penyimpanan tersembunyi; celsius dan fahrenheit adalah tampilan read-only. Pemanggil tidak bisa merusak state internalnya, dan class tetap bebas mengubah cara ia menyimpan nilai itu nanti.

Berikutnya: prototype

Class sebagian besar adalah syntactic sugar di atas sistem prototype JavaScript, model yang lebih tua dan lebih mendasar yang sebenarnya menjadi fondasi bahasa ini. Memahami prototype menjelaskan kenapa this berperilaku seperti itu, bagaimana pewarisan sebenarnya bekerja, dan apa yang di-extends sebuah class di balik layar. Itulah halaman berikutnya.