Getters, Setters & Property Descriptors

Reviewed & published by Brayan K

Getters and setters are special functions that run when you read or assign a property, letting you compute values and validate input behind plain property syntax — while property descriptors control whether each property is writable, enumerable, and configurable.

Part of the free JavaScript course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

They are how you build computed fields, enforce rules on assignment, and lock specific properties without changing how callers use the object.

What You'll Learn in This Lesson

• Define get/set in object literals
• Use get/set inside classes
• Compute and validate properties
• Create properties with defineProperty
• Read and tune descriptor flags
• Inspect with getOwnPropertyDescriptor

📚 Prerequisites: You should know objects, classes, and the basics of how properties work. Getters and setters extend ordinary property access.

⚙️ Real-World Analogy: A getter/setter is like a thermostat dial:

• • Reading the dial (getter) shows a computed temperature, not a raw stored number
• • Turning the dial (setter) doesn't just set a value — it checks the range and triggers the system
• • Descriptors are the screws on the back: they decide if the dial can be removed or relabeled

1️⃣ Getters & Setters in Object Literals

Prefix a function with get or set inside an object literal. A getter runs when you read the property (no parentheses) and is perfect for values derived from other fields. A setter runs when you assign and receives the new value as its single argument — ideal for validation. To callers it all looks like a normal property.

No parentheses: you write person.fullName, not person.fullName(). That's what makes a getter feel like data instead of a method.

const person = {
  first: "Ada",
  last: "Lovelace",
  get fullName() {
    return this.first + " " + this.last;
  },
  set fullName(value) {
    const parts = value.split(" ");
    this.first = parts[0];
    this.last = parts[1];
  },
};

console.log(person.fullName);   // ✅ Expected output: Ada Lovelace

person.fullName = "Grace Hopper"; // setter runs
console.log(person.first);       // ✅ Expected output: Grace
console.log(person.last);        // ✅ Expected output: Hopper

2️⃣ Getters & Setters in Classes (with Validation)

Classes use the same get/set keywords. A common pattern stores the real value in a "private" field (a #name or a leading-underscore convention) and exposes a getter/setter pair that guards it. The setter can throw on bad input, so invalid state never gets stored.

Derived getters stay in sync automatically: fahrenheit recomputes from celsius every time it's read, so there's no stale duplicate value to maintain.

class Temperature {
  #celsius = 0;
  get celsius() { return this.#celsius; }
  set celsius(v) {
    if (v < -273.15) throw new RangeError("below absolute zero");
    this.#celsius = v;
  }
  get fahrenheit() { return this.#celsius * 9 / 5 + 32; }
}

const t = new Temperature();
t.celsius = 25;
console.log(t.celsius);     // ✅ Expected output: 25
console.log(t.fahrenheit);  // ✅ Expected output: 77

try {
  t.celsius = -300;
} catch (e) {
  console.log(e.message);   // ✅ Expected output: below absolute zero
}

3️⃣ Property Descriptors & Object.defineProperty

Every property has a hidden descriptor. Object.defineProperty lets you create or tune a property with explicit flags: writable (can the value change?), enumerable (does it show in loops and Object.keys?), and configurable (can it be deleted or redefined?). Properties defined this way default all three to false. Object.getOwnPropertyDescriptor reveals the current settings.

Normal assignment is generous: a property created with obj.x = 1 is writable, enumerable, and configurable by default. defineProperty flips that to locked-down.

const config = {};

Object.defineProperty(config, "version", {
  value: "1.0",
  writable: false,
  enumerable: false,
});

config.version = "9.9";       // ignored: not writable
console.log(config.version);  // ✅ Expected output: 1.0
console.log(Object.keys(config)); // ✅ Expected output: []

const d = Object.getOwnPropertyDescriptor(config, "version");
console.log(d.writable);      // ✅ Expected output: false
console.log(d.enumerable);    // ✅ Expected output: false

// A normal property is fully open by comparison
config.name = "app";
console.log(Object.getOwnPropertyDescriptor(config, "name").writable); // ✅ Expected output: true

🎯 Your Turn — A Computed Getter

Add a getter area that returns width * height.

const rect = {
  width: 4,
  height: 5,
  // 👉 replace ___ : a getter named area that multiplies the sides
  ___ area() {
    return this.width * this.___;
  },
};

console.log(rect.area);   // ✅ Expected output: 20

🧠 Quick Recall

Predict the output before revealing the answer.

5 — reading o.x runs the getter; note there are no parentheses.

[] — defineProperty defaults enumerable to false.

number — the getter returns the stored number, not a function.

Common Errors & Fixes

• 1️⃣ Calling a getter like a method
• 2️⃣ Getter and stored field share a name → infinite loop
• 3️⃣ Expecting a defineProperty property to be writable
• 4️⃣ Forgetting a setter to make a property writable

🎯 Mini Challenge — Validated Bank Account

Build an account whose balance setter rejects negative values.

class Account {
  #balance = 0;
  get balance() { return this.#balance; }
  set balance(v) {
    if (v < 0) throw new RangeError("balance cannot be negative");
    this.#balance = v;
  }
}

const acc = new Account();
acc.balance = 100;
console.log(acc.balance);     // ✅ Expected output: 100

try {
  acc.balance = -50;
} catch (e) {
  console.log(e.message);     // ✅ Expected output: balance cannot be negative
}
console.log(acc.balance);     // ✅ Expected output: 100

Quick Reference

📚 Keep Learning

• MDN: Object.defineProperty()

🎉 Lesson Complete — Getters, Setters & Descriptors!

• ✅ Getters run on read; setters run on assignment — no parentheses
• ✅ Setters are the place to validate or transform incoming values
• ✅ Class getters/setters pair well with private # fields
• ✅ defineProperty controls writable/enumerable/configurable
• ✅ getOwnPropertyDescriptor reveals a property's real flags

Practice quiz

Continue this course

• Previous: Symbols & Well-Known Symbols
• Next: Proxy & Reflect (Metaprogramming) — Intercept object operations with traps — the basis of modern reactivity
• Quick reference: JavaScript cheat sheet

Frequently asked questions

What is the difference between a getter and a regular method?

A getter is accessed like a property — obj.fullName, with no parentheses — but runs a function behind the scenes each time you read it. A method is called with parentheses — obj.getFullName(). Getters are perfect for computed values that should feel like plain data.

Why use a setter instead of just assigning a property?

A setter intercepts assignment (obj.age = 5) so you can validate, transform, or log the incoming value before storing it. That lets you reject invalid data or keep derived fields in sync, all while callers use ordinary assignment syntax.

What are the three property descriptor flags?

writable controls whether the value can be reassigned, enumerable controls whether the property shows up in loops and Object.keys, and configurable controls whether the property can be deleted or its descriptor changed. Properties created with Object.defineProperty default all three to false.

How do I inspect a property's descriptor?

Call Object.getOwnPropertyDescriptor(obj, 'key') to get an object describing that property — its value (or get/set functions) plus the writable, enumerable, and configurable flags. Object.getOwnPropertyDescriptors returns descriptors for every own property at once.