Simulating Constants in TypeScript: Public Static Readonly vs. Alternatives

2024-07-27

public: This keyword makes a class member accessible from outside the class.
static: This keyword defines a class member that belongs to the class itself, rather than to instances of the class. You can access static members using the class name, without needing to create an object.
const: This keyword declares a constant value. Once assigned, the value cannot be changed.

The issue is with const. TypeScript doesn't allow using const for class properties because the property value needs to be determined at compile time, while const initialization might happen during runtime.

However, you can achieve similar functionality using a combination of public and static with another keyword: readonly. Here's how:

class MyClass {
  public static readonly MY_CONSTANT: string = "This is a constant value";

  // Accessing the constant
  static getConstant() {
    return MyClass.MY_CONSTANT;
  }
}

console.log(MyClass.getConstant()); // Output: "This is a constant value"

In this example:

public static readonly MY_CONSTANT: This declares a static property named MY_CONSTANT that's public (accessible outside the class) and read-only (its value cannot be changed).
The value is assigned during the declaration ("This is a constant value").

class MathConstants {
  public static readonly PI: number = 3.14159;

  public static calculateCircumference(radius: number): number {
    return 2 * MathConstants.PI * radius;
  }
}

console.log(MathConstants.PI); // Output: 3.14159

const circumference = MathConstants.calculateCircumference(5);
console.log(circumference); // Output: 31.4159 (approx)

This example defines a MathConstants class with a public static readonly constant PI. It also has a calculateCircumference method that utilizes the constant.

Enumeration (Enum) with Public Static Readonly:

enum Weekdays {
  Sunday,
  Monday,
  Tuesday,
  Wednesday,
  Thursday,
  Friday,
  Saturday,
}

console.log(Weekdays.Monday); // Output: 1 (index of Monday)

// Weekdays[1] would also access Monday (assuming zero-based indexing)

This example creates an enum Weekdays with days of the week as constants. Since enums are inherently readonly, you can use public static to make them accessible from outside the enum definition.

Getters with public static:

This approach uses a getter method to simulate a constant property. The getter function always returns the same pre-defined value.

class Config {
  private static configValue: string = "default value";

  public static get getConfigValue(): string {
    return Config.configValue;
  }
}

console.log(Config.getConfigValue); // Output: "default value"

Here, configValue is a private static property that holds the actual value. The getConfigValue getter simply returns this value. While it prevents direct modification, it offers less clarity compared to readonly.

Enums (Without public static):

Enums in TypeScript are inherently read-only by default. You can define them without explicitly using public static readonly.

enum Colors {
  Red,
  Green,
  Blue,
}

console.log(Colors.Green); // Output: 1 (index of Green)

This approach works well when you have a fixed set of known values. However, enums have limitations compared to readonly properties, such as the inability to store complex data types.

Choosing the Right Method:

Use public static readonly for most cases where you need a constant-like property within a class. It's clear, concise, and enforces immutability during compilation.
Consider getters if you need more complex logic for retrieving the value or if future modifications might be necessary (though this deviates from the concept of a constant).
Enums are a good choice for representing a set of fixed, known values without the need for complex data types.

typescript