在 TypeScript 中扩展联合类型别名？

Question

我试图在编译时将某些字符串字段限制为仅具有某些值。问题是这些值应该是可扩展的。 这是一个简化的示例：

type Foobar = 'FOO' | 'BAR';

interface SomeInterface<T extends Foobar> {
  amember: T;

  [key: string]: string; // this really has to stay
}

// let's test it

const yes = {
    amember: 'FOO'
} as SomeInterface<'FOO'>; // compiles as expected

//    const no = {
//        amember: 'BAZ'
//    } as SomeInterface<'BAZ'>; // Type '"BAZ"' does not satisfy the constraint 'Foobar' as expected

// so far so good
// Now the problem

abstract class SomeClass<T extends Foobar> {
  private anotherMember: SomeInterface<T>;
}

type Foobarbaz = Foobar | 'BAZ';

class FinalClass extends SomeClass<Foobarbaz> { //no good anymore
}

错误是

类型“Foobarbaz”不满足约束“Foobar”。类型 '"BAZ"' 不能分配给类型 'Foobar'。

所以问题是：如何在打字稿中将“类型”限制为仅属于某些字符串，但是否可以使用其他字符串进行扩展？ 还是这是一个 XY 问题并且有明显更好的解决方案？

Typescript 2.3.4 但我认为如果那里有魔法我可以升级到 2.4。

Answer 1

我认为您使用“可扩展”一词的含义与关键字 extends 的含义不同。通过说类型是“可扩展的”，您是说您希望能够加宽类型以接受更多值。但是当extends 某个类型时，这意味着您正在缩小 类型以接受更少 值。

SomeInterface<T extends Foobar>本质上只能是以下四种类型之一：

• SomeInterface<'FOO'|'BAR'>: amember 可以是'FOO' 或'BAR'
• SomeInterface<'FOO'>:amember只能是'FOO'
• SomeInterface<'BAR'>:amember只能是'BAR'
• SomeInterface<never>: amember 不能取任何值

我有点怀疑这是否真的是你想要的，但只有你自己知道。

---

另一方面，如果您希望将 SomeInterface<T> 定义为 T 可以始终为 FOO 或 BAR，但也可能是其他一些 string 值，您需要 TypeScript 不完全提供的东西，即为 T 指定下限。 SomeInterface<TsuperFoobar extends string> 之类的东西不是有效的 TypeScript。

但您可能只关心 amember 的类型，而不关心 T。如果您希望 amember 是 FOO 或 BAR，但也可能是其他一些 string 值，您可以这样指定：

interface SomeInterface<T extends string = never> {
  amember: Foobar | T;
  [key: string]: string; 
}

其中T 只是您希望允许的额外文字的联合。如果您不想允许任何额外内容，请使用never，或者直接省略类型参数（因为我已将never 作为默认值）。

让我们看看它的实际效果：

const yes = {
    amember: 'FOO'
} as SomeInterface; // good, 'FOO' is a Foobar

const no = {
    amember: 'BAZ'
} as SomeInterface; // bad, 'BAZ' is not a Foobar

abstract class SomeClass<T extends string> {
  private anotherMember: SomeInterface<T>;
}

class FinalClass extends SomeClass<'BAZ'> { 
} // fine, we've added 'BAZ'

// let's make sure we did:
type JustChecking = FinalClass['anotherMember']['amember']
// JustChecking === 'BAZ' | 'FOO' | 'BAR'

---

我回答你的问题了吗？希望对您有所帮助。

Answer 2

要实现您的需要，您可以通过& 符号使用intersection。

type Foobar = 'FOO' | 'BAR';
type FoobarBaz = Foobar | & 'BAZ'; // or: 'BAZ' | & Foobar

Answer 3

如何在 typescript 中将“类型”限制为仅属于某些字符串，但是否可以使用其他字符串进行扩展？

不知道你的 X 问题是什么，但你总是可以引入另一个泛型参数，并通过声明它扩展该参数来限制类型。 Typescript 2.3 supports default types for generic parameters，因此默认使用Foobar，您可以像以前一样使用带有一个参数的SomeInterface，当您需要它来扩展其他内容时，您可以明确提供：

type Foobar = 'FOO' | 'BAR';

interface SomeInterface<T extends X, X extends string=Foobar> {
  amember: T;

  [key: string]: string; // this really has to stay
}

// let's test it

const yes = {
    amember: 'FOO'
} as SomeInterface<'FOO'>; // compiles as expected


abstract class SomeClass<T extends X, X extends string=Foobar> {
  private anotherMember: SomeInterface<T, X>;
}

type Foobarbaz = Foobar | 'BAZ';

class FinalClass extends SomeClass<Foobarbaz, Foobarbaz> { 
}

更新

我想我现在明白了这个问题。一种解决方案是将联合类型（如 Foobar）编码为 keyof 的一些人工接口类型，仅用于表示键（不使用值类型并且无关紧要）。这样，通过扩展界面，您可以“自然”地扩展键集：

interface FoobarKeys { FOO: { }; BAR: { } };

type Foobar = keyof FoobarKeys;

interface SomeInterface<X extends FoobarKeys = FoobarKeys> {
  amember: keyof X;

  [key: string]: string; // this really has to stay
}



abstract class SomeClass<X extends FoobarKeys = FoobarKeys> {
    protected anotherMember: SomeInterface<X> = {
        amember: 'FOO'
    };

    protected amethod(): void { 
        this.bmethod(this.anotherMember); // no error
    }

    protected bmethod(aparam: SomeInterface<X>): void { 

    }
}

// let's extend it

interface FoobarbazKeys extends FoobarKeys { BAZ: {} };
type Foobarbaz = keyof FoobarbazKeys;

class FinalClass extends SomeClass<FoobarbazKeys> {
    private f() {
        this.bmethod({amember: 'BAZ'})
    } 
}