Encapsulation in TypeScript | CodeSignal Learn

Encapsulation in TypeScript | CodeSignal Learn

Let's look at the following TypeScript example to get a better understanding of encapsulation using the private access modifier and type annotations:

TypeScript

class Person {
    private name: string;
    private age: number;

    // Constructor
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

    // Setters
    setName(name: string): void {
        this.name = name;
    }

    setAge(age: number): void {
        if (age >= 0) {
            this.age = age;
        } else {
            console.error('Age cannot be negative.');
        }
    }

    // Getters
    getName(): string {
        return this.name;
    }

    getAge(): number {
        return this.age;
    }
}

// Example usage
const person = new Person('Alice', 30);
person.setName('Bob');
person.setAge(25);

console.log(`Name: ${person.getName()}, Age: ${person.getAge()}`);

In this example, we have a Person class with private fields name and age. The class provides methods (setName, setAge, getName, and getAge) for manipulating and accessing these private fields.

Contrasting `private` and `protected`

Here's a small example to show the difference between private and protected : class Animal {protected species: string; constructor(species: string) {this.species = species;}} class Dog extends Animal {getSpecies(): string {// Can access protected member from subclass return this.species;}} const dog = new Dog('Canine'); console.log(dog.getSpecies()); // Output: Canine // console.log(dog.species); // Error: Property 'species' is protected and only accessible within class 'Animal' and its subclasses. In this example, the species property is marked as protected, so it can be accessed inside the Animal class and its subclass Dog, but not from outside these classes. If species were private, even the Dog subclass would not be able to access it. If we skip setters and getters and make the data fields accessible, we lose control over the data and can't enforce constraints or validations. Encapsulation allows us to protect the object's internal state and provide controlled access to it. Additionally, encapsulation enables us to include logic within setter methods, such as validating that the age is not set to a negative value.

TypeScript

class Animal {
    protected species: string;

    constructor(species: string) {
        this.species = species;
    }
}

class Dog extends Animal {
    getSpecies(): string {
        // Can access protected member from subclass
        return this.species;
    }
}

const dog = new Dog('Canine');
console.log(dog.getSpecies()); // Output: Canine
// console.log(dog.species); // Error: Property 'species' is protected and only accessible within class 'Animal' and its subclasses.