Getters, Setters & Private Fields

Getters and setters let you control how a property is read or written. Private fields hide internal data so the outside world can't accidentally break it.

What Are Getters and Setters?

A getter is a special method that runs when you read a property. A setter is a special method that runs when you write to a property. From the outside, they look just like regular properties — but behind the scenes, code runs automatically.

Getters — get

Use the get keyword to define a getter. It looks like a method but you access it like a property (no parentheses).

class Circle {
  constructor(radius) {
    this.radius = radius;
  }

  get area() {
    return Math.PI * this.radius ** 2;
  }

  get diameter() {
    return this.radius * 2;
  }

  get circumference() {
    return 2 * Math.PI * this.radius;
  }
}

const c = new Circle(5);

c.area;          // 78.54… — reads like a property, runs like a method
c.diameter;      // 10
c.circumference; // 31.41…

// No parentheses! c.area() would throw an error — it's a getter, not a method

• get area() { ... } — defines a getter named area
• c.area — reading this automatically calls the getter function
• The getter returns a computed value — you don't store it separately
• No parentheses when accessing: c.area not c.area()

class Person {
  constructor(firstName, lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  get fullName() {
    return `${this.firstName} ${this.lastName}`;
  }
}

const p = new Person("Alice", "Smith");
p.fullName; // "Alice Smith" — no need to store it separately

p.firstName = "Bob";
p.fullName; // "Bob Smith"  — auto-updates because it's computed

Setters — set

Use the set keyword to define a setter. It runs when you assign a value to that property. Setters are perfect for validating values before they're stored.

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;  // this calls the setter below
  }

  get age() {
    return this._age;
  }

  set age(value) {
    if (typeof value !== "number" || value < 0) {
      throw new Error("Age must be a positive number");
    }
    this._age = value;
  }
}

const p = new Person("Alice", 30);
p.age;      // 30 — calls the getter
p.age = 31; // calls the setter, validates, stores 31
p.age = -5; // throws Error: "Age must be a positive number"

• set age(value) { ... } — runs when you write p.age = something
• this._age — we store the actual value in _age (underscore convention means "internal")
• If we stored in this.age inside the setter, it would call the setter again — infinite loop!
• The getter get age() reads back from this._age
• From outside, you just write p.age = 31 — clean and simple, validation is hidden

class Constant {
  get PI() { return 3.14159; }
}
const c = new Constant();
c.PI = 99; // silently ignored (or throws in strict mode)
c.PI;      // still 3.14159

Private Fields — #

A private field starts with a # and can only be accessed inside the class. Nothing outside — not even a subclass — can read or write it directly. This is called encapsulation: hiding internal details so they can't be accidentally broken from the outside.

class BankAccount {
  #balance = 0;       // private — no one outside can touch this directly
  #owner;             // private — declared here, set in constructor

  constructor(owner, initialBalance) {
    this.#owner = owner;
    this.#balance = initialBalance;
  }

  deposit(amount) {
    if (amount <= 0) throw new Error("Amount must be positive");
    this.#balance += amount;
  }

  withdraw(amount) {
    if (amount > this.#balance) throw new Error("Insufficient funds");
    this.#balance -= amount;
  }

  get balance() {
    return this.#balance; // read-only access via getter
  }

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

const account = new BankAccount("Alice", 100);

account.deposit(50);
account.balance;   // 150 — via getter
account.withdraw(30);
account.balance;   // 120

account.#balance;  // SyntaxError — cannot access private field from outside
account.#balance = 999999; // SyntaxError — cannot write it either

• #balance = 0 — declares a private field with a default value of 0
• #owner — declares a private field (no default; set in constructor)
• this.#balance += amount — accessing private fields inside the class is fine
• get balance() — exposes the private field as read-only from outside
• Trying to do account.#balance outside the class is a SyntaxError — the JS engine rejects it entirely

Private Methods — #method()

Methods can be private too. Use # before the method name. Private methods can only be called from inside the class.

class Form {
  #data = {};

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

  // Private method — internal helper, not part of the public API
  #validate() {
    if (!this.#data.email) {
      throw new Error("Email is required");
    }
    if (!this.#data.name) {
      throw new Error("Name is required");
    }
  }

  submit() {
    this.#validate(); // only accessible inside the class
    console.log("Form submitted!", this.#data);
  }
}

const form = new Form({ name: "Alice", email: "alice@example.com" });
form.submit();   // works — submit() calls #validate() internally
form.#validate(); // SyntaxError — can't call private method from outside

Private Static Fields and Methods

You can combine #private with static:

class IdGenerator {
  static #nextId = 1; // private AND static

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

IdGenerator.generate(); // 1
IdGenerator.generate(); // 2
IdGenerator.generate(); // 3

IdGenerator.#nextId; // SyntaxError — private even from outside the class

Checking if a Private Field Exists — in operator

Since accessing obj.#field on an object that doesn't have that field throws an error (not just undefined), you can use the in operator to safely check:

class Dog {
  #name;
  constructor(name) { this.#name = name; }

  static isDog(obj) {
    return #name in obj; // true if obj has the private #name field
  }
}

Dog.isDog(new Dog("Rex")); // true
Dog.isDog({ name: "Rex" });  // false — plain object, no #name

Putting It All Together

Here's a complete example using private fields, getters, setters, and a private method together:

class Temperature {
  #celsius; // private storage

  constructor(celsius) {
    this.celsius = celsius; // calls the setter
  }

  // Private helper — validates the value
  #checkValid(val) {
    if (val < -273.15) {
      throw new RangeError("Below absolute zero!");
    }
  }

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

  set celsius(val) {
    this.#checkValid(val);  // validate first
    this.#celsius = val;
  }

  // Read-only computed property
  get fahrenheit() {
    return this.#celsius * 9/5 + 32;
  }

  get kelvin() {
    return this.#celsius + 273.15;
  }
}

const t = new Temperature(100);
t.celsius;    // 100
t.fahrenheit; // 212
t.kelvin;     // 373.15

t.celsius = 0;
t.fahrenheit; // 32

t.celsius = -300; // RangeError: Below absolute zero!
t.#celsius;       // SyntaxError — private!

Common Mistakes

class Parent {
  #secret = 42;
}
class Child extends Parent {
  read() {
    return this.#secret; // SyntaxError — #secret belongs to Parent only
  }
}

Best Practices

• Use private fields (#field) for any data that should not be changed directly from outside the class.
• Use a getter to expose computed or derived values as if they were regular properties.
• Use a setter to validate or transform data before storing it.
• When you have both a getter and setter for the same name, always store the real data in a private field (#_name) to avoid infinite loops.
• Prefer #privateField over the old _underscoreConvention — it's actually enforced by the language.

Performance Notes

Getters run a function every time the property is read — if the calculation is expensive and you read it often, consider caching the result. Private fields are just as fast as regular properties in modern engines; the privacy check is done at parse time, not at runtime.

Browser Compatibility

Getters and setters (get/set) have been in JavaScript since ES5 and work everywhere. Private fields (#field) were added in ES2022 and are supported in all modern browsers (Chrome 74+, Firefox 90+, Safari 14.1+, Edge 79+). Private methods are ES2022 as well. For older environments, use the _underscore convention as a fallback.

Interview Questions

Summary

• Getters (get prop()) run a function when you read a property — accessed without parentheses.
• Setters (set prop(value)) run a function when you assign to a property — great for validation.
• Always store the value in a private backing field (#field) when using getters/setters to avoid infinite loops.
• Private fields (#field) are truly inaccessible outside the class — enforced by the JS engine, not just convention.
• Private methods (#method()) work the same way — internal helpers the outside world can't call.
• Combine all three to build classes with controlled, safe interfaces.

Related Topics

• Classes: The Basics
• Inheritance & The super Keyword
• Static Properties & Methods
• Object Methods

MDN reference: developer.mozilla.org → JavaScript → Classes → Private class features / get / set