为什么 TypeScript 不能推断出相同对象类型的赋值？

Question

假设我有一个非常简化的示例来说明我的代码中发生的事情：

interface I {
  n?: number;
  s?: string;
}

const a: I = {
  n: 1,
}

const b: I = {
  n: 2,
  s: 'b',
}

const props = ['n', 's'] as const;

for (const prop of props) {
  if (!a[prop]) {
    // here, I get the following error:
    // TS2322: Type 'string | number' is not assignable to type 'never'.
    //   Type 'string' is not assignable to type 'never'.
    a[prop] = b[prop];
  }
}

作为a 和b 相同的类型，访问相同的属性prop... 不应该是可能的吗？

• 如果b[prop] 是一个数字，那么a[prop] 应该接受数字
• 如果b[prop] 是一个字符串，那么a[prop] 应该接受字符串
• 如果b[prop] 未定义，是因为该属性是可选的?

那么，我在这里错过了什么？

更新：由于我过于简化了我的示例，答案是删除了as const 部分......但我认为这是由于我的环境，因为我使用的是strict: true在tsconfig.json...

然后，如果我尝试在不使用 as const 的情况下访问，我会收到 TS7053 错误：

元素隐式具有“任何”类型，因为“字符串”类型的表达式不能用于索引类型“I”。

在“I”类型上找不到带有“字符串”类型参数的索引签名。

修复添加as const 或执行for(const prop of props as ('n' | 's')[]) {

然后是我收到原始错误的时候（可以使用as any 轻松修复，但我正在努力避免这种情况）

Answer 1

问题出在这一行

const props = ['n', 's'] as const;

改成

const props = ['n', 's'];

检查这个stackblitz

Answer 2

我试过这样和它的工作，你应该删除 props 定义中的 const 值

interface I {
  n?: number;
  s?: string;
}

const a: I = {
  n: 1,
}

const b: I = {
  n: 2,
  s: 'b',
}

const props = ['n', 's'];

for (const prop of props) {
  if (!a[prop]) {
    a[prop] = b[prop];
    console.log(a, b);
  }
}

结果是： {n: 1, s: "b"} {n: 2, s: "b"}

Answer 3

一般来说，Typescript 不会证明代码的所有可证明属性，也不会尝试证明。在这种特殊情况下，我们人类知道 b[prop] 的类型与 a[prop] 的类型匹配，因为属性名称是相同的，但是 Typescript 看不到这一点，因为它没有允许它的规则.

如果我们遵循 Typescript 的逻辑：

• props 被声明为 ['n', 's'] 类型的元组。
• prop 被声明为props 的一个元素，因此其类型被推断为'n' | 's'。
• 由于b 被声明为I 类型，因此b[prop] 被推断为I['n' | 's'] 类型，简化为string | number。
• 由于a 被声明为I 类型，那么赋值目标 a[prop] 只能接收一个可赋值给@987654337 的任何 属性的值@ 可能命名；因此分配目标的类型被推断为I['n'] & I['s']，简化为string & number，然后是never。
• 就 Typescript 而言，赋值 a[prop] = b[prop] 是将 string | number 类型的值赋给 never 类型的赋值目标。由于string | number 不能分配给never，这是一个类型错误。

最简单的解决方法是使用像 b[prop] as any 这样的类型断言，即告诉 Typescript 你知道你的代码是类型安全的，因此不需要检查它。另一种选择是使用辅助函数，它以满足 Typescript 类型检查器的方式执行分配：

function copyMissingProperties<T>(a: T, b: T, props: readonly (keyof T)[]): void {
    for (const prop of props) {
        if (!a[prop]) {
            a[prop] = b[prop]; // ok
        }
    }
}

这里prop的类型是keyof T，不是联合类型，所以赋值目标没有交集类型。

Answer 4

这是我在不使用强制转换的情况下让它工作的一种方法：

interface I {
    n?: number;
    s?: string;
}

const a: I = {
    n: 1,
}

const b: I = {
    n: 2,
    s: 'b',
}

const props: Array<keyof I> = ['n', 's'];

for (const prop of props) {
    if (!a[prop]) {
        const newProp: I = {[prop]: b[prop]};
        Object.assign(a, newProp);
    }
}

诀窍是使用 Object.assign。但是，为了仍然确保类型安全，您可以将新属性声明为 I 类型的对象，然后在 Object.assign 中使用它。为了在所有情况下都能正常工作，最好的方法是只做Object.assign(a, {[prop]: b[prop]})