我可以编写一个断言多个不变量的类型保护吗？

我可以编写一个类型保护来断言一个或多个子对象一个论点？在伪代码中，它可能看起来像这样：

class C {
    a: number?;
    b: string?;

    function assertInitialized() : (this.a is number) and (this.b is string) {
        return this.a !== null && this.b !== null;
    }
}

---

Background: I'd commonly use a single function to check invariants of my classes; for example, assume I have a class with some nullable fields, which get asynchronously initialized.

class DbClient {
    dbUrl: string;
    dbName: string;
    dbConnection: DBConnection?;
    …
}

这个类经历了一个复杂的异步初始化过程，之后dbConnection变为非空。在 dbConnection 初始化之前，该类的用户不得调用某些方法，因此我有一个函数assertReady:

assertReady() {
    if (this.dbConnection === null) {
        throw "Connection not yet established!";
    }
}

这个功能assertReady在每个需要的函数的开头调用DbClient要完全初始化，但我仍然必须编写非空断言：

fetchRecord(k: string) {
    assertReady();
    return this.dbConnection!.makeRequest(/* some request based on k */);
}

我可以给assertReady一个签名使得!不必要？我不想通过this.dbConnection to assertReady，因为该函数通常更复杂。

我知道的唯一技巧是创建一个与当前类具有相同字段的接口，但具有不可为空的类型（没有?）。然后我可以制作一个类型保护程序来表示this is InitializedDbClient。不幸的是，这需要复制类定义的很大一部分。有没有更好的办法？

是的你可以and你在伪代码中几乎完全正确

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

  hasAandB(): this is {a: number} & {b: string};
}

注意你的伪代码是如何的and成为一个&。确实非常接近。

当然，没有必要使用该运算符，类型路口运算符，在这种情况下，因为我们可以将其简化为

hasAandB(): this is {a: number, b: string};

但想象一下我们添加第三个属性，比如说c，它不受类型保护的影响，但我们仍然不想失去它对结果类型的贡献。

您对可组合类型防护的直觉让我们回到原点

hasAandB(): this is this & {a: number, b: string};

您可以使用这些模式做各种非常有趣且非常有用的事情。

例如，您通常可以根据对象的类型传递许多属性键，并且根据您传递的实际键，结果可以针对每个属性的持有者的交集进行类型保护。

function hasProperties<T, K1 extends keyof T, K2 extends keyof T>(
  x: Partial<T>,
  key1: K1,
  key2: K2
): x is Partial<T> & {[P in K1 | K2]: T[P]} {
  return key1 in x && key2 in x;
}


interface I {
  a: string;
  b: number;
  c: boolean;
}

declare let x: Partial<I>;

if (hasProperties(x, 'a', 'b')) {...}

事实上，这只是触及了可能性的表面。

另一个非常有趣的应用是定义任意通用和类型安全的构建器和可组合工厂。