根据参数返回不同接口的Typescript

我想根据传递给方法的参数返回不同的接口。这就是我到目前为止所做的：

interface A {
    a: string;
}
interface B {
    b: string;
}
interface C {
    c: string;
}

export enum Type {
  A = 'a',
  B = 'b',
  C = 'c',
}
interface Configs {
  a: A;
  b: B;
  c: C;
}

const get = <C extends Type>(name: C): Configs[C] => {
    if (name === Type.A) {
        return { a: 'true' } as A;
    }

    if (name === Type.B) {
        return { b: 'true' } as B;
    }

    if (name === Type.C) {
        return { c: 'true' } as C;
    }

    throw new Error('Unknown type')
}

// This works correctly
const b = get(Type.B);

接口A{
a:弦；
}
接口B{
b:弦；
}
接口C{
c：字符串；
}
导出枚举类型{
A=‘A’，
B=‘B’，
C=‘C’，
}
接口配置{
a:a；
b:b；
c:c；
}
const get=（名称：C）：配置[C]=>{
if（name==Type.A）{
返回{a:'true'}作为；
}
如果（名称===Type.B）{
将{b:'true'}返回为b；
}
if（name==Type.C）{
将{c:'true'}返回为c；
}
抛出新错误（'未知类型'）
}
//这是正确的
常数b=get（类型b）；

方法的使用正确；如果我执行

get（Type.B）

操作，实际上我会返回正确的接口

---

但是，该方法本身在

return

语句中给了我错误，说A&B&C中缺少

属性“x”。如何编写此方法？
我们可以使用
Config[C]
作为返回类型。我们传递参数，然后泛型函数获取类型
C
，然后获取
Config[C]
的类型

然而，您有3个返回语句，它们的类型不同，
A
、
B
、
C
，因此编译器认为此函数的返回类型是
A&B&C
，然后抱怨
类型“A”不能分配给类型“A&B&C”
或其他什么

所以您应该只使用
Config[C]
作为返回类型，并且编译器知道它是什么类型

接口A{
a:弦；
}
接口B{
b:弦；
}
接口C{
c：字符串；
}
导出枚举类型{
A=‘A’，
B=‘B’，
C=‘C’，
}
接口配置{
a:a；
b:b；
c:c；
}
//使用（名称：C）应该更好
const get=（名称：C）：配置[C]=>{
if（name==Type.A）{
返回{a:'true'}作为配置[C]；
}
如果（名称===Type.B）{
返回{b:'true'}作为配置[C]；
}
if（name==Type.C）{
返回{c:'true'}作为配置[c]；
}
抛出新错误（'未知类型'）
}
//这是正确的
常数b=get（类型b）；

您可以在这里看到：
我们可以使用
Config[C]
作为返回类型。我们传递参数，然后泛型函数获取类型
C
，然后获取
Config[C]
的类型

然而，您有3个返回语句，它们的类型不同，
A
、
B
、
C
，因此编译器认为此函数的返回类型是
A&B&C
，然后抱怨
类型“A”不能分配给类型“A&B&C”
或其他什么

所以您应该只使用
Config[C]
作为返回类型，并且编译器知道它是什么类型

接口A{
a:弦；
}
接口B{
b:弦；
}
接口C{
c：字符串；
}
导出枚举类型{
A=‘A’，
B=‘B’，
C=‘C’，
}
接口配置{
a:a；
b:b；
c:c；
}
//使用（名称：C）应该更好
const get=（名称：C）：配置[C]=>{
if（name==Type.A）{
返回{a:'true'}作为配置[C]；
}
如果（名称===Type.B）{
返回{b:'true'}作为配置[C]；
}
if（name==Type.C）{
返回{c:'true'}作为配置[c]；
}
抛出新错误（'未知类型'）
}
//这是正确的
常数b=get（类型b）；

你可以在这里看到操场：