从typescript中的基类泛型推断子类属性类型 甲级 { 一些：{[K in keyof T]：（x:T[K]）=>T[K]} } 接口IB{ b:号码 } B类扩展了A类 { 构造函数（） { 超级（） /** *键入“{b:（x:T[“b”]）=>number；}” *不可分配给类型“{[K in keyof T]：（x:T[K]）=>T[K]；}”。 */ 这个。有些={ b:x=>2*x } } } 接口集成电路{ b:号码 c:布尔型 } C类扩展到B类 { 构造函数（） { 超级（） /** *键入“{b:（x:T[“b”]）=>number；c:（x:T[“c”]）=>boolean；}” *不可分配给类型“{[K in keyof T]：（x:T[K]）=>T[K]；}” */ 这个。有些={ b:x=>4*x， c:x=>！x } } }

你好。我试图在基类“A”中设置泛型约束，目的是自动推断派生类中“某些”属性的类型。不幸的是，我不明白为什么我会出现上面提到的TS错误。在我看来，一切似乎都很好

---

谢谢大家!

如果我这样做会发生什么

    class A<T>
    {
        some: { [K in keyof T]: (x: T[K]) => T[K] }
    }

    interface IB {
        b: number
    }

    class B<T extends IB> extends A<T>
    {
        constructor()
        {
            super()

            /**
             * Type '{ b: (x: T["b"]) => number; }'
             * is not assignable to type '{ [K in keyof T]: (x: T[K]) => T[K]; }'.
             */
            this.some = {
                b: x => 2*x
            }
        }
    }

    interface IC {
        b: number
        c: boolean
    }

    class C<T extends IC> extends B<T>
    {
        constructor()
        {
            super()
            /**
             * Type '{ b: (x: T["b"]) => number; c: (x: T["c"]) => boolean; }'
             * is not assignable to type '{ [K in keyof T]: (x: T[K]) => T[K]; }'
             */
            this.some = {
                b: x => 4*x,
                c: x => !x
            }
        }
    }

这将允许

B

和

C

构造函数初始化

一些

，而无需知道额外的属性

现在，关于

b:3

。如果您想允许某人扩展

号码

，那么您可以使用的唯一安全功能是标识功能：

class A<T>
{
  some: {[K in keyof T]?: (x: T[K]) => T[K]}
}

但是对于

b

的类型，您可能不希望任何人传入比

number

更具体的内容。不幸的是，没有什么好办法来阻止它。所以，很好，只需记录用户应该只传入

b

可以是任何

number

的类型。在这种情况下，您只需告诉编译器不要担心，断言

this

属于

B

类型：

this.some={}；
（这是B.some.B=x=>2*x；//可以

---

您的

C

类也可以进行类似的修复。希望有帮助；祝你好运

这是一个非常详细的答案：）现在在你的帮助下一切都清楚了。非常感谢你！

class A<T>
{
  some: {[K in keyof T]?: (x: T[K]) => T[K]}
}

this.some = {};
this.some.b = x => x; // okay

this.some = {};
(this as B<IB>).some.b = x => 2 * x; // okay