typescript private readonly vs 类之外的 const [关闭]

Question

我想知道最好的方法是什么，或者在引用同一文件中的类常量之外是否有任何后果。

当我声明一个接收无效参数时会抛出错误的简单类时会出现问题：

export class Digit {
  private _value: number = null;

  constructor(value: number) {
    this._value = value;
  }

  set value(value: number) {
    if (isNaN(value)) { throw new Error('Received NaN as digit.'); }

    this._value = value;
  }

  get value() {
    return this._value;
  }

}

value setter 永远不会在构造函数中触发，因为需要实例化该类。

因为我想让事情变得简单，我只希望这个示例类包含一个有效数字或根本不存在，所以我不想在其 值 上使用 null 来实例化它.这导致我得到以下代码：

export class Digit {
  private _value: number = null;

  constructor(value: number) {
    if (isNaN(value)) { throw new Error('Received NaN as digit.'); }

    this._value = value;
  }

  set value(value: number) {
    if (isNaN(value)) { throw new Error('Received NaN as digit.'); }

    this._value = value;
  }

  get value() {
    return this._value;
  }

}

效果很好，但现在我在重复自己！想象一下对 10 个或更多字段进行这样的验证。

所以我想到了两个解决方案：

1- 重构为类内部的验证函数

export class Digit {
  private _value: number = null;

  private readonly validateValue = function (value: number): number {
    if (isNaN(value)) { throw new Error('Received NaN as digit.'); }

    return value;
  };

  constructor(value: number) {
    this._value = this.validateValue(value);
  }

  set value(value: number) {
    this._value = this.validateValue(value);
  }

  get value() {
    return this._value;
  }

}

我喜欢这种方法，因为所有业务逻辑都包含在类中。但是如果您选择不尊重私有范围，它仍然可以在此之外访问。 我不喜欢它的事情是，随着越来越多的字段和验证被添加，类很容易变得混乱，然后它会分散注意力，因为你可能想要修复一些行为，因为你知道你的实例值是正确的.

2- 重构为类外但在同一个文件中的验证函数

const validateValue = function (value: number): number {
  if (isNaN(value)) { throw new Error('Received NaN as digit.'); }

  return value;
};

export class Digit {
  private _value: number = null;

  constructor(value: number) {
    this._value = validateValue(value);
  }

  set value(value: number) {
    this._value = validateValue(value);
  }

  get value() {
    return this._value;
  }

}

我喜欢这种方法的地方在于，我可以直接进入我的课程代码，前提是值是正确且经过验证的，并且我不会在课堂上被它们分心。另外，我不能选择省略私有作用域并访问其验证器。

此外，如果验证变得非常广泛，我可以选择为该类创建一个帮助程序并在文件之外重构验证（不知道这是否是一种不好的做法）。

另一方面，我不知道在类声明之外使用这些的后果。

那么解决这个问题的最佳方法是什么？两种解决方案都有效吗？有更好的方法吗？

Answer 1

我不确定这里有一个“正确”的答案。我个人更希望有一个设置值的实现，然后您可以从构造函数中调用该实现。

export class Digit {
  private _value: number = null;

  constructor(value: number) {
    this.setValue(value);
  }

  set value(value: number) {
    this.setValue(value);
  }

  get valor() {
    return this._value;
  }

  private setValue(value: number) {
    if (isNaN(value)) { throw new Error('Received NaN as digit.'); }
    this._value = value;
  }

}

Answer 2

我会亲自介绍另一种类型，例如NotNaN:

type NotNaN = number & { __notNaN: true };

然后你可以为此编写一个验证器：

function notNaN(n: any): n is NotNaN {
  return !isNaN(n);
}

并相应地键入您的类属性：

class Digit {
  constructor(public value: NotNaN) { }
}

然后你可以这样写：

let digit = new Digit(12 as NotNaN);
let someValue = +prompt("Surprise me!");

// Properly checked, works:
if(notNaN(someValue)) {
  digit.value = someValue;
}

// Not properly checked:
digit.value = someValue;
// TypeError: type 'number' is not assignable to type 'NotNaN'

这样，您可以完全避免 getter / setter。抛出错误不是一个好主意，相反，您应该正确验证输入和操作，这就是强制执行的。