TypeScript中Class与Interface的never类型约束差异及适配方案

我在TypeScript中实现了一个带私有属性的泛型类A，现在需要将其转换为支持多实现的接口B，但发现never类型的赋值规则出现了不一致：类中非法的never赋值会触发报错，但接口中却能通过类型校验。我需要让接口B的行为和类A完全一致，同时不能将私有属性暴露为公共属性，也不能修改原有的公共属性和方法。

代码示例 #

class A<TX, TY> {
    #x?: TX | undefined;
    #y?: TY | undefined;
}

interface B<TX, TY> {
    // 不希望x和y是公共属性
}

never类型的行为差异 #

类A的测试代码中，非法赋值会按预期报错：

function a(i: boolean): A<number, never> {
    // 预期仅返回A<number, 'str'>合法
    if(i) {
        return new A<never, 'str'>(); // 报错：类型'A<never, "str">'不能赋值给类型'A<number, never>'
    }
    return new A<number, never>(); // 无报错
}

而接口B的测试代码中，非法赋值却能通过校验：

function b(i: boolean): B<number, never> {
    // 此处应该报错，仅返回B<number, 'str'>才合法
    if(i) {
        return null as unknown as B<never, 'str'>; // 无报错，不符合预期
    }
    return null as unknown as B<number, never>; // 无报错
}

需遵循的赋值规则 #

需要确保泛型参数的赋值严格遵循以下逻辑：

• 若目标类型的泛型参数为never，则仅允许赋值never类型
• 若目标类型的泛型参数为非never类型T，则允许赋值T或never类型

应通过校验的场景 #

function a(): A<never, never>   { return new A<never, never>(); }
function a(): A<string, number> { return new A<never, never>(); }
function a(): A<boolean, never> { return new A<true, never>(); }
function a(): A<string, string> { return new A<never, 'foo'>(); }

应校验失败的场景 #

function a(): A<never, never>   { return new A<string, never>(); }
function a(): A<never, never>   { return new A<never, boolean>(); }
function a(): A<never, string>  { return new A<string, never>(); }
function a(): A<boolean, never> { return new A<never, number>(); }

解决方案：模拟私有属性的兼容性约束 #

类A的严格赋值规则来源于私有属性——TypeScript会认为只有同一类的实例才兼容，泛型参数的兼容性也会因此被严格校验。要让接口B拥有相同的行为，可以通过唯一符号属性模拟私有属性的约束，无需暴露真实的私有属性：

// 定义唯一符号，避免与其他属性冲突
const privateX = Symbol.for('B.private.x');
const privateY = Symbol.for('B.private.y');

interface B<TX, TY> {
    // 用符号属性模拟私有属性的兼容性约束
    [privateX]?: TX;
    [privateY]?: TY;
}

此时再测试接口B的赋值：

function b(i: boolean): B<number, never> {
    if(i) {
        return null as unknown as B<never, 'str'>; // 现在会报错：类型不兼容，符合预期
    }
    return null as unknown as B<number, never>; // 无报错
}

原理：符号属性是全局唯一的，TypeScript会检查这些属性的类型兼容性，就像类的私有属性一样，从而强制泛型参数遵循和类A一致的赋值规则。

内容的提问来源于stack exchange，提问作者Benjamin M