类既是值又是类型

 1// 类既是值又是类型
 2
 3class C {
 4  a = "123";                    // 实例属性
 5  static version = "1.0";       // 静态属性
 6
 7  constructor(public n: number) {}
 8
 9  method(): string { return this.a; }
10  static create(): C { return new C(0); }
11}
12
13// ---- 值位置：C 是构造函数 ----
14const ctor = C;                  // ✓ C 是值
15console.log(typeof C);           // "function"
16const instance = new C(1);
17
18// ---- 类型位置：C 是实例类型 ----
19let c: C = new C(2);             // ✓ C 也是类型
20// 注意：作为类型时，C 表示"实例的类型"，不含静态成员
21
22// ---- 关键区别：C 与 typeof C ----
23// C（类型位置）= 实例类型：有 a, n, method
24// typeof C      = 构造函数类型：有 version, create, prototype
25
26// 实例类型：能访问实例成员
27const inst: C = new C(3);
28console.log(inst.a, inst.n, inst.method());
29
30// 构造函数类型：能访问静态成员
31const ctorTyped: typeof C = C;
32console.log(ctorTyped.version, ctorTyped.create().n);
33
34// ---- 常见错误：把类当实例用 ----
35// 原归档笔记里的经典问题：
36class D { a = "123" }
37const d: D = new D();
38console.log(d);        // D { a: '123' }
39console.log(D);        // [class D]
40// @ts-expect-error TS2339: a 是实例属性，不在类（构造函数）上
41console.log(D.a);
42
43// ---- 用 typeof C 表达"传入一个类" ----
44function instantiate<T>(Ctor: new (...args: any[]) => T): T {
45  return new Ctor();
46}
47const made = instantiate(C);   // T 推断为 C
48
49// 更精确的构造函数类型
50type Ctor<T> = new (...args: any[]) => T;
51function make<T>(ctor: Ctor<T>): T { return new ctor(); }
52
53// 静态侧 + 实例侧一起约束
54interface WithCreate<T> {
55  create(): T;
56}
57function fromStatic<T, S extends WithCreate<T>>(Static: S): T {
58  return Static.create();
59}
60const fromStaticResult = fromStatic(C);
61
62// ---- 抽象类的类型 ----
63abstract class Base {
64  abstract run(): string;
65  static helper() { return "h"; }
66}
67// typeof Base 包含静态成员
68const baseStatic: typeof Base = Base;
69console.log(baseStatic.helper());
70// @ts-expect-error TS2511: 抽象类不能实例化
71new Base();
72
73// ---- 接口实现类时的类型关系 ----
74interface HasA { a: string }
75// 实例类型满足接口
76const asInterface: HasA = new C(4);
77// 但 typeof C 不满足（构造函数没有 a）
78// @ts-expect-error TS2741: typeof C 缺少 a
79const ctorAsInterface: HasA = C;
80
81console.log(ctor, instance, c, ctorTyped, made, make(C), fromStaticResult, asInterface, ctorAsInterface);

1function
2123 3 123
31.0 0
4D { a: '123' }

1class C {
2  a = "123";                // 实例属性
3  static version = "1.0";   // 静态属性
4  method(): string { }
5  static create(): C { }
6}
7
8const ctor = C;              // ✓ 值位置：C 是构造函数
9let c: C = new C();          // ✓ 类型位置：C 是实例类型

1const inst: C = new C();          // C 作类型 = 实例类型
2const ctorTyped: typeof C = C;    // typeof C = 构造函数类型

1inst.a;            // ✓ 实例成员
2inst.method();     // ✓
3
4ctorTyped.version; // ✓ 静态成员
5ctorTyped.create(); // ✓

1class D { a = "123" }
2
3const d: D = new D();
4console.log(d);     // D { a: '123' }  ← 实例
5console.log(D);     // [class D]      ← 构造函数
6
7console.log(D.a);
8// error TS2339: Property 'a' does not exist on type 'typeof D'.

1interface HasA { a: string }
2
3const asInterface: HasA = new C(4);   // ✓ 实例满足
4
5const ctorAsInterface: HasA = C;
6// error TS2741: Property 'a' is missing in type 'typeof C' but required in type
7// 'HasA'.

1interface Serializable { serialize(): string }
2
3class Foo implements Serializable {
4  serialize() { return ""; }     // 必须是实例方法
5}

1// 泛型构造函数类型
2function instantiate<T>(Ctor: new (...args: any[]) => T): T {
3  return new Ctor();
4}
5
6const made = instantiate(C);   // T 推断为 C

1type Ctor<T> = new (...args: any[]) => T;
2function make<T>(ctor: Ctor<T>): T { return new ctor(); }

1interface WithCreate<T> {
2  create(): T;
3}
4
5function fromStatic<T, S extends WithCreate<T>>(Static: S): T {
6  return Static.create();
7}

 1abstract class Base {
 2  abstract run(): string;
 3  static helper() { return "h"; }
 4}
 5
 6const baseStatic: typeof Base = Base;   // ✓ 静态侧可用
 7baseStatic.helper();
 8
 9new Base();
10// error TS2511: Cannot create an instance of an abstract class.