Static Members in TypeScript

In TypeScript, static members (properties and methods) belong to the class itself rather than to instances of the class. Static members are accessed via the class name, not through an instance of the class. This is useful when you want to share data or behavior that should be common to all instances of a class.

 

Key Points About Static Members:

1. Static members are declared using the static keyword.
2. Static members can be accessed directly on the class, without needing to create an instance.
3. Static members cannot be accessed from instance methods unless specifically referenced through the class name.

 

Declaring Static Properties

Static properties are defined using the static keyword, and they are shared by all instances of the class.

Example:

class Counter {
  static count: number = 0;

  constructor() {
    Counter.count++;  // Static property accessed via the class name
  }

  static resetCount(): void {
    Counter.count = 0;  // Static method can also access static properties
  }
}

console.log(Counter.count);  // Output: 0
const counter1 = new Counter();
const counter2 = new Counter();
console.log(Counter.count);  // Output: 2

Counter.resetCount();
console.log(Counter.count);  // Output: 0

In this example:

• The count property is static, so it's shared across all instances of the Counter class.
• The resetCount() method is static, so it can be called without creating an instance of the class.
• Each time a new instance is created, the count property is incremented.

Declaring Static Methods

Static methods are functions that belong to the class itself. These methods can be called directly on the class, not on an instance.

Example:

class MathUtility {
  static add(a: number, b: number): number {
    return a + b;
  }

  static subtract(a: number, b: number): number {
    return a - b;
  }
}

console.log(MathUtility.add(5, 3));  // Output: 8
console.log(MathUtility.subtract(5, 3));  // Output: 2

In this example:

• add and subtract are static methods, so they are called directly on the MathUtility class without needing an instance.

Static Members and Instance Members

Static members are distinct from instance members. Instance members require an object instance to access, while static members belong to the class itself.

Example:

class Car {
  static numberOfCars: number = 0;
  make: string;
  model: string;

  constructor(make: string, model: string) {
    this.make = make;
    this.model = model;
    Car.numberOfCars++;  // Increment the static property
  }

  static getCarCount(): number {
    return Car.numberOfCars;  // Static method accessing static property
  }
}

const car1 = new Car("Toyota", "Corolla");
const car2 = new Car("Honda", "Civic");

console.log(Car.numberOfCars);  // Output: 2
console.log(Car.getCarCount());  // Output: 2

In this example:

• The numberOfCars property is static and keeps track of how many Car instances have been created.
• The getCarCount() method is static and can be called directly from the class to retrieve the count.
• The instance properties make and model belong to individual objects.

Static Initialization

Static members are initialized only once, when the class is first used. This allows you to initialize shared data or behavior before any instances are created.

Example:

class Database {
  static isConnected: boolean = false;

  static connect(): void {
    if (!Database.isConnected) {
      Database.isConnected = true;
      console.log("Database connected.");
    } else {
      console.log("Already connected.");
    }
  }
}

Database.connect();  // Output: Database connected.
Database.connect();  // Output: Already connected.

In this example:

• The isConnected static property tracks the connection status.
• The connect() static method establishes a connection if not already connected, demonstrating how static properties can be used to manage global state.

 

Summary

Static members in TypeScript are used when you want to define properties or methods that belong to the class itself rather than any individual instance.

• Static properties are shared across all instances of the class.
• Static methods can be called on the class directly, without needing an instance.
• Static members can be useful for global data management or utility functions, and they are initialized once when the class is first used.

By using static members appropriately, you can manage class-level data and behavior more effectively.