Generic Class Static Typing Runtime Validation

In TypeScript, generic classes provide highly reusable type definition capabilities through the static type system, while combining them with runtime validation mechanisms to achieve stronger type safety.
Generic classes allow specifying type parameters at definition time, thereby achieving type reusability. For example, by defining a generic Queue<T> class, one can flexibly handle queues of different types.

class Queue<T> {
  private data: T[] = [];

  enqueue(item: T): void {
    this.data.push(item);
  }

  dequeue(): T | null {
    return this.data.length > 0 ? this.data.shift() : null;
  }
}

The static type system ensures the type safety of the class through generic parameters; for instance, the compiler checks whether the parameter type of the enqueue method matches T, avoiding type errors.

Runtime Validation

TypeScript's runtime validation mechanism is implemented via the Reflect API, such as checking whether an object's properties and methods conform to expected types.

const queue = new Queue<string>();
queue.enqueue(123); // Compiler will report an error because `123` is not of type `string`

Although types are detected at compile time, runtime behavior can still be validated using Reflect.getPrototypeOf to verify the object's prototype chain and ensure type consistency.

Combining Static Typing with Runtime Validation

The static typing system of generic classes complements the runtime validation mechanism:

Static typing ensures the accuracy of type definitions and prevents compile-time errors.
Runtime validation further guarantees type safety by examining the actual runtime behavior of objects.
For example, in Queue<T>, runtime validation checks whether the parameter type of the enqueue method is T, while the static type system ensures type consistency at compile time.

Type Assertions and Runtime Validation

TypeScript supports type assertions (as) and type guards (such as typeof); when combined with runtime validation, these mechanisms can further enhance type safety.

const value: number = 100 as unknown as string;  
console.log(value); // Compiler will report an error because `number` and `string` types do not match

Runtime validation uses typeof to check the type, ensuring the correctness of assignment operations.

Practical Application Scenarios

In actual development, combining the static typing of generic classes with runtime validation can effectively avoid type errors. For example:

When using Map<unknown, unknown>, runtime validation checks whether the key-value pair types match.
When handling third-party libraries, the static type system ensures interface type consistency, while runtime validation verifies object types via Reflect.getPrototypeOf.
Through this mechanism, developers can obtain type guarantees at compile time and further ensure type safety at runtime by examining the actual behavior of objects.