Getters and Setters in TypeScript

Getters and setters are a fundamental concept in object-oriented programming, allowing you to control access to an object’s properties. In TypeScript, getters and setters provide a way to define custom logic for getting and setting property values. This tutorial will guide you through the basics of using getters and setters in TypeScript.

Introduction to Getters and Setters

In TypeScript, getters and setters are special methods that allow you to intercept and modify the behavior of property access and modification. A getter is a method that returns the value of a property, while a setter is a method that sets the value of a property.

Defining Getters and Setters

To define a getter or setter in TypeScript, you use the get and set keywords followed by the name of the property. Here’s an example:

class Person {
    private _name: string;

    get name(): string {
        return this._name;
    }

    set name(value: string) {
        this._name = value;
    }
}

In this example, we define a Person class with a private _name property. We then define a getter and setter for the name property using the get and set keywords.

Using Getters and Setters

To use getters and setters, you access the property as if it were a regular property. The getter is called when you read the property value, and the setter is called when you assign a new value to the property.

const person = new Person();
person.name = 'John Doe'; // calls the setter
console.log(person.name); // calls the getter

Example Use Cases

Getters and setters are useful in a variety of scenarios:

• Validation: You can use setters to validate input data before assigning it to a property.

class Person {
    private _name: string;

    get name(): string {
        return this._name;
    }

    set name(value: string) {
        if (value.length > 10) {
            throw new Error('Name is too long');
        }
        this._name = value;
    }
}

• Computed Properties: You can use getters to compute property values on the fly.

class Rectangle {
    private _width: number;
    private _height: number;

    get area(): number {
        return this._width * this._height;
    }

    set width(value: number) {
        this._width = value;
    }

    set height(value: number) {
        this._height = value;
    }
}

• Read-Only Properties: You can use getters to implement read-only properties.

class Person {
    private _name: string;

    constructor(name: string) {
        this._name = name;
    }

    get name(): string {
        return this._name;
    }
}

Best Practices

When using getters and setters, keep the following best practices in mind:

• Use meaningful property names: Choose property names that are descriptive and easy to understand.
• Keep getters and setters simple: Avoid complex logic in getters and setters. If you need to perform complex calculations or validations, consider using separate methods.
• Document your code: Use comments and JSDoc tags to document your getters and setters, making it easier for others to understand how they work.

By following these guidelines and examples, you can effectively use getters and setters in TypeScript to create more robust and maintainable object-oriented code.