Object Getters & Setters in JavaScript

In JavaScript, getters and setters are special methods that allow you to control access to object properties. They make objects more dynamic and secure by letting you:

Control how a property is read (getter)
Control how a property is updated (setter)

Using getters and setters, you can add logic (like validation or computation) when accessing or modifying property values — instead of directly exposing them.

Getters

A getter allows you to define a method that’s called when a property is accessed.

Syntax:

const obj = {
  firstName: "John",
  lastName: "Doe",

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

console.log(obj.fullName); // "John Doe"

Setters

A setter defines a method that’s called when a property is assigned a value.

Syntax:

const obj = {
  firstName: "John",
  lastName: "Doe",

  set fullName(name) {
    const parts = name.split(" ");
    this.firstName = parts[0];
    this.lastName = parts[1];
  }
};

obj.fullName = "Jane Smith";
console.log(obj.firstName); // "Jane"
console.log(obj.lastName);  // "Smith"

Getters & Setters Together

You can use both together to create controlled property access.

This approach makes fullName behave like a normal property — but internally, it runs logic when read or written.

const person = {
  firstName: "John",
  lastName: "Doe",

  get fullName() {
    return `${this.firstName} ${this.lastName}`;
  },
  set fullName(name) {
    const [first, last] = name.split(" ");
    this.firstName = first;
    this.lastName = last;
  }
};

person.fullName = "Alice Brown";
console.log(person.fullName); // "Alice Brown"

Using `Object.defineProperty()`

You can also define getters and setters using Object.defineProperty() for more control (e.g., making them non-enumerable).

const user = { firstName: "John", lastName: "Doe" };

Object.defineProperty(user, "fullName", {
  get() {
    return `${this.firstName} ${this.lastName}`;
  },
  set(value) {
    const [first, last] = value.split(" ");
    this.firstName = first;
    this.lastName = last;
  }
});

console.log(user.fullName); // "John Doe"
user.fullName = "Mary Jane";
console.log(user.firstName); // "Mary"

Practical Use Cases

Use Case	Description
Data Validation	Check if the value being assigned is valid before updating.
Computed Values	Combine or process multiple properties into one (e.g., `fullName`, `totalPrice`).
Encapsulation	Hide internal logic and expose a clean interface.
Logging / Debugging	Track property changes for analytics or debugging.

Example: Validation with Setter

_balance is a private-like property (by convention, underscore _), and the setter ensures that negative balances are not allowed.

const account = {
  _balance: 0,

  get balance() {
    return this._balance;
  },

  set balance(amount) {
    if (amount < 0) {
      console.log("Invalid balance!");
    } else {
      this._balance = amount;
    }
  }
};

account.balance = 1000;
console.log(account.balance); // 1000
account.balance = -500;       // "Invalid balance!"

Advantages

Adds encapsulation (controls access to object properties).
Enables data validation and transformation.
Supports computed or derived values.
Makes APIs cleaner by using property-like syntax.

Summary Table

Concept	Description	Example
Getter	Defines behavior when property is read	`get fullName() { ... }`
Setter	Defines behavior when property is assigned	`set fullName(name) { ... }`
Access	Use like a normal property	`obj.fullName`
Define Property	Alternative definition method	`Object.defineProperty()`

JavaScript Handbook