JavaScript Getters and Setters
Last Updated :
20 Feb, 2025
In JavaScript, getter and setter are the special methods introduced in ECMAScript 5 (ES5 2009) that allow us to retrieve and modify the values directly without directly changing the object property. The getter uses the get keyword and the setter uses the set keyword to modify and retrieve the values.
JavaScript Getter (The get Keyword)
In JavaScript, the getter is the method that is used to get the value of the property. We can use the get keyword to get the value of the property.
- Getters are automatically called when the property is accessed.
- Getters help us in getting the value of the property.
JavaScript
class P {
constructor(name) {
this._name = name;
}
get name() {
return this._name;
}
}
const res = new P('Anjali');
console.log(res.name);
In this example
- The Person class has a constructor that sets the _name property
- get method used to retrieve the value of _name when a name is accessed.
- When person.name is accessed, the getter name is automatically called, returning the value of _name.
Getter vs Regular Function
In JavaScript, the getter and the regular functions both are used for the accessing the object properties but in the different ways. Getters allow properties to be accessed like regular object attributes while still executing logic in the background. On the other hand, regular functions require explicit method calls and do not provide direct property-like access.
Feature | Getter (get) | Regular Function |
---|
Syntax | Accessed like a property (obj.prop) | Called explicitly (obj.method()) |
---|
Readability | Improves readability & simplicity | equires () which makes it look like a method call |
---|
Encapsulation | Can restrict direct access to properties | Properties can be easily accessed |
---|
JavaScript Setter (The set Keyword)
In JavaScript, the setter is the method that is used for setting the value of the property with the help of the set keyword.
- The setter allows us to set the value of the object in a controlled way.
- Setters provide a way to control how data is stored by using internal variables, keeping the object's state secure.
JavaScript
class P {
constructor(name) {
this._name = name;
}
set name(newName) {
this._name = newName;
}
}
const res = new P('Anjali');
res.name = 'Ayushi'; // Using the setter to change the name
console.log(res._name); // Output: Ayushi
In this example
- The setter name is used to update the _name property when res.name = 'Ayushi' is called.
- The value of _name is updated to 'Ayushi'.
Implementing Getters and Setters in JavaScript
Using Getters and Setters in Objects
In objects, we can use the get and set keywords for defining the getter and setter in objects.
JavaScript
const p= {
n1: "Anurag",
n2: "Das",
get Name() {
return `${this.n1} ${this.n2}`;
},
set Name(name) {
[this.n1, this.n2] = name.split(" ");
}
};
console.log(p.Name);
p.Name = "Anuj Jain";
console.log(p.Name);
OutputAnurag Das
Anuj Jain
Getters and Setters with Classes
Getters and setters are commonly used in ES6 classes to control access to private properties.
JavaScript
class R {
constructor(width, height) {
this.width = width;
this.height = height;
}
get a() {
return this.width * this.height;
}
set a(value) {
console.log("Area cannot be set directly.");
}
}
const rect = new R(10, 5);
console.log(rect.a);
rect.a = 60;
Output50
Area cannot be set directly.
The getter computes the area dynamically, and the setter prevents modification, enforcing encapsulation.
Using Getters and Setters with Private Fields
With ES2020, JavaScript introduced private fields (prefix _ is just a convention; # makes it truly private).
JavaScript
class B {
#balance; // Private property
constructor(balance) {
this.#balance = balance;
}
get balance() {
return this.#balance;
}
set balance(amount) {
if (amount < 0) {
console.log("Balance cannot be negative!");
} else {
this.#balance = amount;
}
}
}
const acc = new B(1000);
console.log(acc.balance);
acc.balance = -500; // "Balance cannot be negative!"
Output1000
Balance cannot be negative!
The #balance field is private, ensuring external code cannot modify it directly.
Using Object.defineProperty() for Accessors
The Object.defineProperty() method can define getters and setters dynamically.
JavaScript
const u = { name: "Anjali" };
Object.defineProperty(u, "greeting", {
get: function () {
return `Hello, ${this.name}!`;
},
set: function (newName) {
this.name = newName;
}
});
console.log(u.greeting);
u.greeting = "Ayushi";
console.log(u.greeting);
OutputHello, Anjali!
Hello, Ayushi!
This approach allows defining dynamic properties with controlled access.
Use Cases of Getters and Setters
- Data Validation: Ensures only valid data is assigned to a variable, preventing errors.
- Lazy Computation: Delays the calculation of a value until it's actually needed, improving efficiency.
- Encapsulation: Hides direct access to sensitive data, allowing controlled modifications through methods.
- Debugging & Logging: Helps track when and how a variable changes, making it easier to find bugs.
When to Use Getters and Setters?
When you need to validate input before assigning a value.
set age(value) {
if (value < 0) throw new Error("Age cannot be negative!");
this._age = value;
}
When properties depend on other properties (computed properties).
get fullName() {
return `${this.firstName} ${this.lastName}`;
}
When working with private fields in classes.
class Person {
#secret = "Hidden Data";
get secret() {
return "Access Denied";
}
}
When debugging changes in properties.
set value(newValue) {
console.log(`Value changed to: ${newValue}`);
this._value = newValue;
}
Getters and Setters vs. Direct Property Access
Feature | Getters & Setters | Direct Property Access |
---|
Definition | Special methods used to control the access and modification of object properties. | Directly assigning and retrieving values from an object's properties without any additional control. |
---|
Use Cases | Used when validation, computed properties, encapsulation, or logging is required. | Used for simple data storage where additional logic is not needed. |
---|
Performance | Slightly slower due to method calls. | Faster since it directly accesses properties. |
---|
Encapsulation | Provides encapsulation by restricting direct access to internal data. | No encapsulation; data can be freely modified. |
---|
Simplicity | More complex as it requires defining getter/setter methods. | Easier to use since properties can be accessed directly. |
---|
Similar Reads
JavaScript Object Accessors There are two keywords that define the accessors functions: a getter and a setter for the fullName property. When the property is accessed, the return value from the getter is used. When a value is set, the setter is called and passed the value that was set. JavaScript Getter (The get Keyword)Exampl
2 min read
Get and Set in TypeScript In TypeScript, you can use the get and set keywords to define getter and setter methods within a class. These methods allow you to encapsulate the access and modification of class properties, providing a way to control and customize the behavior. In this article, we are going to learn to get and set
3 min read
How to use getters/setters in TypeScript ? In TypeScript, getters and setters provide controlled access to class properties, enhancing encapsulation and flexibility.Getters allow you to retrieve the value of a property with controlled logic.Setters enable controlled assignment to properties, often including validation or transformations.Java
5 min read
TypeScript Accessor TypeScript accessors, through get and set methods, offer controlled access to object properties, enhancing encapsulation, validation, and custom logic. By using accessors, you can manage how properties are accessed and modified, supporting a more robust object-oriented design in your classes.Getters
3 min read
What are getters and setters methods in PHP ? In object-oriented programming, getters and setters are methods used to access and modify the private or protected properties of a class. These methods provide a controlled way to retrieve and update the values of class properties, promoting encapsulation and maintaining the integrity of an object's
3 min read