在构造函数中处理 Typescript 类型检查

Question

使用以下（非常人为的）示例，其中：

如果 object 具有某个属性的特定值，则必须定义另一个（可选）属性。 我想在构造函数中捕获错误，以便用户立即捕获问题。

稍后在一个方法中，我想依赖我们之前执行的类型检查。 有没有办法向下“级联”此检查，或利用我们在 class 其他地方的构造函数中所做的检查？ 一般来说，是否有更优雅的方式来构建这种类型的流程？

interface ExampleOptions {
  someType: "basic" | "needsExtra"
  extra?: string  
}

class Example {
  readonly someType: "basic" | "needsExtra";
  readonly extra?: string;
  
  constructor(opts: ExampleOptions){
    this.someType = opts.someType
    this.extra = opts.extra
    
    // handle type checking here to raise error immediately
    if (this.someType === "needsExtra" && !this.extra) {
      throw new Error("gotta define extra when using type 'needsExtra'")
    }
  }

  doSomething() {
   return this.someType === "basic" ? 
    Example.helper(this.someType) : Example.helperExtra(this.someType, this.extra) // this throws
  }

  private static helper(someType: string): string {
    return someType
  }

  private static helperExtra(someType: string, extra: string) {
    return `${someType}${extra}`
  }
}

doSomething()方法引发异常：

Argument of type 'string | undefined' is not assignable to parameter of type 'string'.
  Type 'undefined' is not assignable to type 'string'.(2345)

即使我们从构造函数中知道这个值将被初始化。 我总是可以在方法中添加另一个检查，但那是多余的。 我相信使用! （非空断言）运算符不受欢迎。

Answer 1

doSomething() 方法告诉我您将两个类压缩在一个类中。 构造函数显示相同的东西，但它也受到使用类作为属性容器的影响，而不是真正的 OOP。

对于更简洁的代码和真正的 OOP 和多态性，我的建议是声明一个接口并在两个或多个实现当前代码的替代路径的类中实现它：

interface Example {
  doSomething();
}


class BasicExample implements Example {
  // this class does not even need a constructor

  public doSomething() {
    return 'basic';
  }
}

class AdvancedExample implements Example {
  public constructor(private extra: string) { 
    // depending on what you understand by `!this.extra`, this constructor
    // might need or might not need to do anything more
    // the TypeScript compiler already prevents invoking the constructor
    // without a value for parameter `extra`
  }

  public doSomething() {
    return `needsExtra${extra}`;
  }
}

很明显，您在问题中发布的示例代码过于简单，实际代码的功能比我上面所做的要多。

然而，通过将不同的东西分离到不同的类中，可以使代码更清晰、更有条理并且更易于阅读和理解。

Answer 2

使用两种类型的联合，而不是单一类型。

更多的

完整的简化示例：

type ExampleOptions = {
    someType: "basic" | "needsExtra"
    extra?: string
}

type Better =
    | { someType: 'basic' }
    | { someType: 'needsExtra', extra: string }

class Example {
    constructor(readonly config: Better) { }
    doSomething() {
        return this.config.someType === "basic" ?
            [this.config.someType] : [this.config.someType, this.config.extra]; // OK! 
    }
}