Class Getter/Setter in TypeScript
Getters and setters in TypeScript classes
In TypeScript classes, getters and setters let you control how a property is read and written, while keeping a clean, property‑like API.
They are mainly used for encapsulation, validation, computed values, and controlled access.
1. Basic idea
Instead of accessing a field directly:
user.age = 30;
console.log(user.age);
You intercept access using get and set.
class User {
private _age = 0;
get age() {
return this._age;
}
set age(value: number) {
this._age = value;
}
}
Usage looks the same:
const user = new User();
user.age = 25; // calls setter
console.log(user.age); // calls getter
2. Why use getters and setters?
They allow you to:
Validate values before assignment
Compute values dynamically
Make properties read‑only or write‑restricted
Hide internal implementation details
3. Validation example (very common)
class User {
private _age = 0;
get age(): number {
return this._age;
}
set age(value: number) {
if (value is negative) {
throw new Error("Age cannot be negative");
}
this._age = value;
}
}
Now invalid assignments are blocked.
4. Computed properties (getter only)
Getters do not need a backing field.
class Rectangle {
constructor(
public width: number,
public height: number
) {}
get area(): number {
return this.width * this.height;
}
}
Usage:
const r = new Rectangle(10, 5);
r.area; // 50
This looks like a property but behaves like a function.
5. Read‑only properties via getter
If you define only a getter, the property becomes read‑only.
class User {
constructor(private _id: string) {}
get id() {
return this._id;
}
}
const user = new User("abc");
user.id = "def"; // Error: no setter
6. Getter and setter types
TypeScript enforces strict typing.
class Product {
private _price = 0;
get price(): number {
return this._price;
}
set price(value: number) {
this._price = value;
}
}
Getter and setter must use the same type.
7. Access modifiers with getters and setters
You can control visibility.
class Account {
private _balance = 0;
public get balance() {
return this._balance;
}
private set balance(value: number) {
this._balance = value;
}
}
Readable from outside, writable only inside the class.
8. Getters and setters vs methods
Using methods:
user.getAge();
user.setAge(30);
Using getters and setters:
user.age;
user.age = 30;
This gives:
Cleaner API
Easier refactoring
More idiomatic TypeScript and JavaScript
9. Common mistake: infinite recursion
Incorrect:
set age(value: number) {
this.age = value; // calls setter again
}
Correct:
set age(value: number) {
this._age = value;
}
10. When to use getters and setters
Use them when:
Validation is needed
Values are derived or computed
You want controlled write access
Internal fields should be hidden
Avoid them when:
A simple public field is enough
No logic is required
Quick summary
get runs when a property is read
set runs when a property is written
They are accessed like normal properties
Ideal for validation, computed values, and encapsulation