为何对象解构剩余值无法被推断为泛型的合法实例？

先看问题中的代码：

type MyType = {
    a: string;
}

function f<T extends Record<string, unknown>>(x: T): T {
    return x;
}

function g<T extends Record<string, unknown>>(fn: (x: T) => T): (y: T & MyType) => void {
    return function(y) {
        const { a, ...rest } = y;
        console.log(`got ${a} for a`);
        fn(rest); // 此处报错
    }
}

错误原因 #

你猜测的第一个原因是正确的：T中可能包含a属性，这会导致解构后的rest无法匹配T的类型。

举个实际例子：如果T是{a: number, b: string}，那么T & MyType的a属性类型会是string & number（实际等价于never类型），解构后rest仅为{b: string}——但原T要求必须包含a属性，所以rest显然不符合T的类型要求，TypeScript编译器会直接报错。

TypeScript的类型系统是严格的，它不会默认假设T中不包含a字段，因此无法自动推断rest就是T类型。

解决方法 #

根据不同业务场景，有几种可行的方案：

方案1：约束T不包含a属性 #

修改泛型约束，确保T中不存在a字段，这样解构后的rest就能完全匹配T类型：

type MyType = {
    a: string;
}

function f<T extends Omit<Record<string, unknown>, 'a'>>(x: T): T {
    return x;
}

function g<T extends Omit<Record<string, unknown>, 'a'>>(fn: (x: T) => T): (y: T & MyType) => void {
    return function(y) {
        const { a, ...rest } = y;
        console.log(`got ${a} for a`);
        fn(rest); // 不再报错
    }
}

方案2：直接传递整个y给fn #

如果业务场景允许忽略MyType的额外属性（或T的属性与MyType属性兼容），可以直接把y传给fn——因为T & MyType是T的子类型，TypeScript会允许这种传递：

function g<T extends Record<string, unknown>>(fn: (x: T) => T): (y: T & MyType) => void {
    return function(y) {
        console.log(`got ${y.a} for a`);
        fn(y); // 直接传递y
    }
}

注意：如果T中也定义了a属性，那么y.a的类型会是T['a'] & string，只有当T['a']与string兼容时，这种方式才不会有类型冲突。

方案3：使用类型断言（谨慎使用） #

如果你能确保业务逻辑中T绝不会包含a属性，可以用类型断言跳过编译器检查：

function g<T extends Record<string, unknown>>(fn: (x: T) => T): (y: T & MyType) => void {
    return function(y) {
        const { a, ...rest } = y;
        console.log(`got ${a} for a`);
        fn(rest as T); // 类型断言
    }
}

这种方式存在风险：如果后续代码中T被传入包含a的类型，会引发运行时潜在问题，仅在你能完全控制T的使用场景时使用。

内容的提问来源于stack exchange，提问作者Jared Smith