Encapsulation in TypeScript: Safeguarding Data with Private Members and Accessors

Hello! Today's journey ventures into the cornerstone of TypeScript's object-oriented fundamentals: Encapsulation. This concept establishes a protective barrier around an object's data, thereby preventing it from being accessed by the external code ecosystem. Let's dive in.

Encapsulation serves three main purposes: it maintains integrity, controls data modification, and provides data abstraction — interfaces that are accessible to users. Think of using a cell phone; you interact with an interface without interfering with its circuits. Following this logic, encapsulation safeguards the internal implementation while exposing safe interfaces.

Now, let's discuss Private Data: In TypeScript, we can specify private data using the keyword private. These data fields cannot be accessed outside the class. We will illustrate this with a Car class, introducing a private attribute called _speed:

class Car {
    private _speed: number; // private speed attribute

    constructor() {
        this._speed = 0; // Initialize speed with 0
    }
}

This class has a private member, _speed, which cannot be accessed directly outside the class. The underscore _ before speed is a naming convention that indicates it is a private attribute.

Getters and Setters are tools used to control access to private data. In our Car class, a getter function retrieves the _speed attribute, while a setter function modifies it as follows:

class Car {
    private _speed: number; // Private speed attribute

    constructor() {
        this._speed = 0; // Initialize speed with 0
    }

    get speed(): number { // Get current speed
        return this._speed;
    }

    set speed(value: number) { // Update speed
        // Speed should stay in the range 0 to 150
        if (value < 0) {
            this._speed = 0;
        } else if (value > 150) {
            this._speed = 150;
        } else {
            this._speed = value;
        }
    }
}

These methods allow us to retrieve or change the car's speed in a safe manner.

Armed with these concepts, we can construct a Car class that showcases encapsulation:

class Car {
    private _model: string; // private model attribute
    private _speed: number;

    constructor(model: string) {
        this._model = model; // Initialize model
        this._speed = 0; // Initialize speed with 0
    }
    
    get model(): string { // Getter for model
        return this._model;
    }

    get speed(): number { // Getter for speed
        return this._speed;
    }

    set speed(value: number) { // Setter for speed
        // Speed should be between 0 and 150
        this._speed = value < 0 ? 0 : (value > 150 ? 150 : value);
    }
}

And, here is how we will use this class (keep in mind that when using get/set methods, we don't use parentheses):

// Create a new Car instance
let myCar = new Car("Toyota");

// `myCar.model` and `myCar.speed` implicitly call the corresponding getter methods
console.log(myCar.model); // Outputs: "Toyota"
console.log(myCar.speed); // Outputs: 0

// Attempt to set speed beyond its limit
// `myCar.speed = ...` implicitly calls the setter method
myCar.speed = 200;
console.log(myCar.speed); // Outputs: 150, because the speed limit is 150

// Attempt to set a negative speed
myCar.speed = -10;
console.log(myCar.speed); // Outputs: 0, because the speed cannot be negative

These codes demonstrate private attributes in action, employing getters and setters and encapsulating the inner workings of the Car class.

Great job getting this far. As a result of this lesson, your toolbelt now includes:

• An understanding of private data
• Knowledge about the roles of getters and setters

Inscribe these lessons into your programming mind and continue your journey! There are hands-on exercises in store for you — they offer practical experience and help bond your understanding of the concepts learned. Keep following the path to becoming a TypeScript pro — the journey is worth it!