How to Use Class Constants in TypeScript?

Using class constants in TypeScript is a straightforward process. Class constants are typically defined as static readonly properties within the class, marked with readonly, meaning their values cannot be modified after initialization. This is a common practice for storing values that should remain immutable and are closely tied to the class.

Example:

Assume we are developing a game where we need a class to represent a player. Player types have predefined attributes, such as the default health value for each type. We can implement this using class constants.

typescript
class Player {
    // Define class constants
    static readonly DEFAULT_HEALTH: number = 100;

    private health: number;
    private name: string;

    constructor(name: string, health?: number) {
        this.name = name;
        // If no health value is provided in the constructor, use the default health value
        this.health = health ?? Player.DEFAULT_HEALTH;
    }

    displayPlayerInfo() {
        console.log(`${this.name} has ${this.health} health points.`);
    }
}

// Usage of the class
let player1 = new Player("Alice");
player1.displayPlayerInfo();  // Output: Alice has 100 health points.

let player2 = new Player("Bob", 90);
player2.displayPlayerInfo();  // Output: Bob has 90 health points.

In this example, DEFAULT_HEALTH is a class constant, defined as a static property of the Player class with the readonly modifier. This ensures its value cannot be modified after initialization. The constructor checks whether a custom health value is provided; if not, it defaults to DEFAULT_HEALTH.

Advantages:

1. Immutability: Using readonly enforces data immutability, meaning values cannot be altered after assignment. This helps prevent runtime errors in the program.
2. Maintainability: Class constants are centrally managed, making them easy to update and maintain across the codebase.
3. Readability: Using class constants improves code clarity and understandability, as they clearly indicate fixed values related to the class.

By leveraging class constants, we can guarantee that critical values remain consistent throughout the program's lifecycle. All related operations can reliably depend on these constant values, thereby enhancing code safety and maintainability.