Typescript 如何将泛型类型限制为与另一泛型类型相同的子类型？

我想声明一个表示某个对象变化的类型

例如：

const测试：SomeType={
答:1,，
b:“福”
};
常量更改1:更改={
obj：测试，
是：{
a:测试
},
现在：{
a:3
}//正确的
常量更改2:更改={
obj：测试，
是：{
a:测试
},
现在：{
b:“酒吧”
}//不正确

我已经试着这样做了：

类型更改={
obj:T，
是:K,，
现在：P
}

---

其想法是将p限制为K的扩展，但使用相同的成员。它似乎不是这样工作的。

我们可以使用映射类型为每个属性构建所有可能的选项，然后将所有选项提取到一个联合中。这将使您认为是错误的情况成为错误：

interface SomeType {
    a: number,
    b: string
}
const test: SomeType = {
    a: 1,
    b: "foo"
};

const changing1: Changing<SomeType> = {
    obj: test,
    was: {
        a: test.a
    },
    now: {
        a: 3
    } 
}

const changing2: Changing<SomeType> = { // error
    obj: test,
    was: {
        a: test.a
    },
    now: {
        b: "bar"
    }  
}

type Changing<T> = {
    [P in keyof T]: {
        obj: T,
        was: Pick<T, P>
        now: Pick<T, P>
    }
}[keyof T]

接口类型{
a:号码，
b:字符串
}
常量测试：SomeType={
答:1,，
b:“福”
};
常量更改1:更改={
obj：测试，
是：{
a:测试
},
现在：{
a:3
} 
}
常量更改2:更改={//错误
obj：测试，
是：{
a:测试
},
现在：{
b:“酒吧”
}  
}
类型更改={
[P in keyof T]：{
obj:T，
是：挑选
现在：选择
}
}[keyof T]

我们可以使用映射类型为每个属性构建所有可能的选项，然后将所有选项提取到一个联合中。这将使您认为是错误的情况成为错误：

interface SomeType {
    a: number,
    b: string
}
const test: SomeType = {
    a: 1,
    b: "foo"
};

const changing1: Changing<SomeType> = {
    obj: test,
    was: {
        a: test.a
    },
    now: {
        a: 3
    } 
}

const changing2: Changing<SomeType> = { // error
    obj: test,
    was: {
        a: test.a
    },
    now: {
        b: "bar"
    }  
}

type Changing<T> = {
    [P in keyof T]: {
        obj: T,
        was: Pick<T, P>
        now: Pick<T, P>
    }
}[keyof T]

接口类型{
a:号码，
b:字符串
}
常量测试：SomeType={
答:1,，
b:“福”
};
常量更改1:更改={
obj：测试，
是：{
a:测试
},
现在：{
a:3
} 
}
常量更改2:更改={//错误
obj：测试，
是：{
a:测试
},
现在：{
b:“酒吧”
}  
}
类型更改={
[P in keyof T]：{
obj:T，
是：挑选
现在：选择
}
}[keyof T]

它实际上是有效的！谢谢！但是我能以某种方式使这两个选择成为T的同一子集吗？您这样做的方式只禁止没有这两个选择交集的情况。（{a，b}和{b，c}可以工作，但不能）@是否允许任何键的组合，只要它们是相同的键？可以这样做，但不需要额外的功能。上述生成并集的方法在可能的情况下不会像生成所有可能的组合那样有效（而且是黑客的）对于编译器来说是非常昂贵的。谢谢你的解释！它实际上是有效的！谢谢！但是我能以某种方式使这两个选择成为T的相同子集吗？你这样做的方式只禁止没有这两个选择相交的情况。（{a，b}和{b，c}可以工作，但不能）@你想允许任何键的组合，只要它们是相同的键？这是可以做到的，但不需要额外的功能。上述生成并集的方法不会像生成所有可能的组合那样有效，而可能的（和黑客的）对编译器来说是非常昂贵的。谢谢你的解释！