并非所有属性都匹配时不显示 typescript 类型检查错误

Question

如果接口(interface) A 和接口(interface) B 只有一个公共(public)属性，则不会显示像这样的 typescript 编译器错误。为什么？

Type '{ a: string; c: number; }' is not assignable to type 'A'.
  Object literal may only specify known properties, and 'c' does not exist in type 'A'. 

此错误不仅应显示为 。对象字面量 还有 接口(interface) .

任何人都可以回答以下问题吗？ (第一季度、第二季度、第三季度)

有什么方法可以检查得更严格吗？

interface A {
    a?: string;
    b?: number;
}

interface B {
    a?: string;
    c?: number;
}

interface C {
    x?: string;
}

const f = (args: A[]) => {
    console.log(args);
};

// (1) error: type check 
const x = () => {
    f([{ a: 'a', c: 1 }]);
};

// (2) no error. Q1. what is the difference between (1) and (2)?
const y = () => {
    const args = [
        { a: 'a', c: 1 }
    ]
    f(args);
};

// (3) error: A and C have no common property
const z = () => {
    f([] as C[]);
};

// (4) no error. [Q2] what is the difference between (3) and (4)?
const w = () => {
    f([] as B[]);
};

// (5) error: A and C have no common property
const u = () => {
    f([{ x: 1 } as C]);
};

// (6) no error. [Q3] what is the difference between (5) and (6)?
const v = () => {
    f([{ c: 1 } as B]);
};

Playground Link

Answer 1

(1) 和 (2) 有什么区别？

// (1) error: type check 
const x = () => {
    f([{ a: 'a', c: 1 }]);
};

// (2) no error. 
const y = () => {
    const args = [
        { a: 'a', c: 1 }
    ]
    f(args);
};

在 (1) 中，有一个显式类型 A为您在 f 中作为数组参数项创建的对象字面量给出.因此 excess property checks (开发人员的一个简洁的安全功能!)启动，它不允许像 c 这样的附加属性. ==> 错误

(2)中 const args的类型由编译器推断(无显式类型)，此处没有多余的属性检查。 [{ a: 'a', c: 1 }] structurally适合 f功能参数 A[] ，因为编译器至少识别出一个属性 a来自 A在你给定的 args .和属性(property) b在 A是可选的/可以是 undefined ( TS docs example 带有“公共(public)属性”)==> 编译

修复 (2) - 注释显式类型:

// now errors
const args: A[] = [
        { a: 'a', c: 1 }
]

(3) 和 (4) 有什么区别？

// (3) error: A and C have no common property
const z = () => {
    f([] as C[]);
};

// (4) no error. 
const w = () => {
    f([] as B[]);
};

使用 (3) 中的类型断言，您说编译器将处理 [] as C[] . C不可分配/没有 A 的子类型, 所以 C[]不能传递给期望 A[] 的东西. B可分配给 A ，这样就行了! (4)。

(5) 和 (6) 有什么区别？

// (5) error: A and C have no common property
const u = () => {
    f([{ x: 1 } as C]);
};

// (6) no error. 
const v = () => {
    f([{ c: 1 } as B]);
};

(5) 如上: C不适合 A . (6) 更有趣:你强制执行 { c: 1 }成为 B ，这是有效的。而且这种类型的断言破坏了过多的属性检查，因此该论点再次符合结构。

鉴于您在 (4) 和 (6) 中的类型断言，尚不清楚/取决于上下文，我们如何“使其更严格”。也许完全忽略断言？

希望，除了 mentioned question 之外还有帮助.