TypeScript 里 class 定义 static 方法的

static 是一个关键字，它的设计为 TypeScript 编程语言提供了简洁的方式来创建类级别的方法和属性。它有着重要的意义，对于理解和使用面向对象编程范式来说非常有用。

static 修饰符的基本概念

在 TypeScript 中，static 是用来声明类的静态成员的一个关键字。被 static 修饰的方法或属性称为静态方法或静态属性。顾名思义，这些静态成员是属于整个类的，而不是属于某个特定实例的。也就是说，这些静态方法或属性是直接通过类本身访问的，而不是通过类的实例访问。

通常情况下，类中的方法和属性都是为每个实例单独提供的。每次创建一个类的实例时，都会创建一组新的属性和方法，这些属性和方法与其他实例之间是隔离的。而静态成员则有所不同，它们与类本身相关，而不是与某个特定的实例相关。

使用 static 修饰符的特点如下：

1. 静态方法和属性可以通过类本身访问，而不是通过类的实例。
2. 静态成员在类的所有实例之间共享，通常用于存放工具函数或类级别的常量。

举一个简单的例子来说明：

class MathUtils {
    static PI = 3.14159;

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

// 访问静态属性和静态方法
console.log(MathUtils.PI); // 输出 3.14159
console.log(MathUtils.calculateCircumference(5)); // 输出 31.4159

在这个例子中，MathUtils 类包含一个静态属性 PI 和一个静态方法 calculateCircumference。我们可以看到，这些成员是通过 MathUtils 类本身进行访问的，而不是通过某个实例。

静态成员的使用场景

静态成员通常用于以下几种场景：

1. 工具类方法或属性：当某个方法或属性不依赖于实例的状态，且仅用于实现某种功能时，就可以使用静态方法。这些方法通常是一些工具函数，例如数学计算、字符串处理等。

2. 共享数据或常量：当需要在类的所有实例之间共享某些数据时，可以将这些数据定义为静态属性。例如，某个应用程序的配置常量、最大连接数等信息，可以用静态属性来存储。

3. 单例模式：在单例模式中，我们可以通过静态方法来控制类的实例化，从而保证一个类只有一个实例。例如，数据库连接类通常使用单例模式来管理。

详细示例

为了更好地理解静态成员的应用场景，下面我会详细阐述一个 TypeScript 示例，演示如何使用 static 成员实现工具类以及单例模式。

示例 1：工具类

工具类是一种非常典型的使用 static 成员的场景。例如，我们可以创建一个专门用于字符串处理的工具类，它包含各种字符串处理方法。

class StringUtils {
    // 静态方法，用于将字符串转换为大写
    static toUpperCase(str: string): string {
        return str.toUpperCase();
    }

    // 静态方法，用于检查一个字符串是否为空
    static isEmpty(str: string): boolean {
        return str.length === 0;
    }
}

// 使用 StringUtils 类的静态方法
console.log(StringUtils.toUpperCase('hello')); // 输出 'HELLO'
console.log(StringUtils.isEmpty('')); // 输出 true
console.log(StringUtils.isEmpty('OpenAI')); // 输出 false

在这个例子中，StringUtils 类包含两个静态方法：toUpperCase 和 isEmpty。这两个方法都没有依赖于实例状态，而是单纯对输入的字符串进行操作，因此它们非常适合用 static 修饰。我们可以通过 StringUtils 类本身调用这些方法，而无需创建实例。

示例 2：共享常量

假设我们在开发一个网络应用程序，可能会使用到一些全局的配置常量，例如 API 的根路径。这些常量可以通过静态属性来实现，从而在整个应用中方便地共享。

class AppConfig {
    static readonly API_BASE_URL: string = 'https://api.example.com/v1';
    
    static getApiEndpoint(endpoint: string): string {
        return `${AppConfig.API_BASE_URL}/${endpoint}`;
    }
}

// 使用 AppConfig 类的静态属性和静态方法
console.log(AppConfig.API_BASE_URL); // 输出 'https://api.example.com/v1'
console.log(AppConfig.getApiEndpoint('users')); // 输出 'https://api.example.com/v1/users'

在这个示例中，AppConfig 类包含一个静态属性 API_BASE_URL，用于存储 API 的根路径。通过使用静态属性，我们可以确保在整个应用中使用统一的 URL 地址，而不是在各处硬编码相同的字符串。此外，静态方法 getApiEndpoint 可以方便地构造 API 的完整路径。

示例 3：单例模式

单例模式是一种常用的设计模式，确保一个类只有一个实例。在 TypeScript 中，我们可以使用静态属性和静态方法来实现单例模式。下面是一个简单的单例模式实现示例：

class Singleton {
    // 静态属性，用于保存唯一的实例
    private static instance: Singleton;

    // 私有化构造函数，防止外部创建实例
    private constructor() {
        console.log('Singleton instance created');
    }

    // 静态方法，用于获取唯一的实例
    static getInstance(): Singleton {
        if (!Singleton.instance) {
            Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }

    // 一个普通方法，供实例使用
    public sayHello(): void {
        console.log('Hello from Singleton');
    }
}

// 使用 Singleton 类
const singleton1 = Singleton.getInstance(); // 输出 'Singleton instance created'
singleton1.sayHello(); // 输出 'Hello from Singleton'

const singleton2 = Singleton.getInstance();
singleton2.sayHello(); // 输出 'Hello from Singleton'

// 验证两个实例是否相同
console.log(singleton1 === singleton2); // 输出 true

在这个例子中，我们通过静态属性和静态方法实现了一个简单的单例模式：

• 使用静态属性 instance 来保存类的唯一实例。
• 构造函数被私有化，防止从外部创建新的实例。
• 提供一个静态方法 getInstance，用于获取唯一的实例。如果实例不存在，则创建它；如果已经存在，则直接返回。

通过这种方式，Singleton 类保证了自己在程序中只有一个实例，而不管调用多少次 getInstance 方法，返回的都是同一个对象。

使用静态成员的注意事项

使用静态成员虽然有诸多好处，但在使用时也需要注意一些事项，以避免代码设计上的问题：

1. 不要滥用静态方法和属性：静态方法和属性是与类相关的，而不是与实例相关的。如果某个方法或属性需要依赖实例的状态，那么就不应该将其声明为静态的。此外，滥用静态成员会导致代码难以测试和维护，特别是当静态成员之间存在复杂依赖时。

2. 不可通过类的实例访问静态成员：静态成员只能通过类本身访问，而不是通过类的实例访问。如果试图通过实例来访问静态成员，TypeScript 编译器会报错。例如，下面的代码是不合法的：

   class Demo {
       static greet(): void {
           console.log('Hello from Demo');
       }
   }
   
   const demoInstance = new Demo();
   demoInstance.greet(); // 错误：Property 'greet' is a static member of type 'Demo'
   

3. 对静态属性进行只读修饰：对于一些不希望被修改的静态属性，可以使用 readonly 关键字修饰。例如，在前面的例子中，我们使用 static readonly API_BASE_URL 来确保 API_BASE_URL 不会被修改。

4. 线程安全性问题：在多线程环境中，使用静态成员可能会引入线程安全性的问题，尤其是在修改静态属性时。如果类需要在多线程环境下工作，建议在设计时考虑到线程安全。

静态成员与非静态成员的对比

静态成员和非静态成员的对比能够帮助更好地理解它们的各自用途：

• 静态成员：属于类本身。可以通过类名直接访问，不需要实例化对象。适用于与特定实例无关的功能。
• 非静态成员：属于类的实例。需要通过类的实例对象来访问。适用于需要保存实例状态的信息和行为。

例如，假设我们要设计一个车辆类 Car，每个 Car 实例都有自己的车牌号和型号，但所有 Car 的速度限制是相同的。我们可以使用静态属性来表示速度限制，而其他信息则作为非静态属性：

class Car {
    static speedLimit: number = 120; // 静态属性，所有实例共享

    licensePlate: string;
    model: string;

    constructor(licensePlate: string, model: string) {
        this.licensePlate = licensePlate;
        this.model = model;
    }

    drive(): void {
        console.log(`${this.model} with license plate ${this.licensePlate} is driving under speed limit ${Car.speedLimit} km/h`);
    }
}

// 创建两个 Car 实例
const car1 = new Car('ABC-123', 'Toyota');
const car2 = new Car('XYZ-789', 'Honda');

// 调用实例方法
car1.drive(); // 输出 'Toyota with license plate ABC-123 is driving under speed limit 120 km/h'
car2.drive(); // 输出 'Honda with license plate XYZ-789 is driving under speed limit 120 km/h'

// 修改静态属性
Car.speedLimit = 100;

car1.drive(); // 输出 'Toyota with license plate ABC-123 is driving under speed limit 100 km/h'
car2.drive(); // 输出 'Honda with license plate XYZ-789 is driving under speed limit 100 km/h'

在这个示例中，speedLimit 是一个静态属性，表示所有车辆的速度限制。我们通过类名 Car 直接访问和修改 speedLimit，所有的实例都会受到影响。而车牌号和型号则是与具体车辆实例相关的信息，因此被定义为非静态属性。

静态成员的设计原则

在设计类的时候，如何决定一个成员是否应该是静态的，通常取决于该成员的作用：

• 如果该成员用于描述所有实例的通用特性，例如配置参数、工具方法、常量等，就适合定义为静态成员。
• 如果该成员用于描述具体对象的特性或行为，例如对象的属性、具体操作方法等，则应定义为非静态成员。

总的来说，静态成员能够让我们更加方便地对类的全局状态进行管理，例如存储常量、创建工具函数以及实现单例模式等。在编程实践中，合理地使用静态成员可以减少重复代码，提高代码的可维护性和可读性。

总结

static 修饰符在 TypeScript 中是一个非常有用的工具，它可以用来创建类级别的属性和方法，而不是每个实例都需要重复拥有。使用 static 可以减少内存占用，提高代码效率，并简化管理全局状态。

通过工具类、共享常量、单例模式等例子，我们可以看到 static 的应用非常广泛，尤其适用于不依赖于实例状态的功能。合理使用静态成员可以帮助开发者编写更简洁、高效的代码，但在使用时也需要注意避免滥用，以免导致代码难以维护。