打字稿中的最终关键字？

Question

有没有办法让变量可以只分配一次？像这样

interface IFACE{
 a: number;
 final b: number;
}

IFACEConstructor (a: number): IFACE {
 return {a: a, b: 1}
}

test = IFACEConstructor(2);
test.a = 5 //OK
test.b = 2 //Error

Answer 1

它将从1.4开始提供,您可以查看Announcing TypeScript 1.4文章"Let/Const"支持部分:

"除了'var'之外,TypeScript现在支持使用'let'和'const'.这些目前需要ES6输出模式,但我们正在研究在未来的版本中放宽这个限制."

Const应该根据文章来实现.

你可以在这里获得TypeScript 1.4 .

更新1

当然,"const与最终的不一样".问题是"有没有办法让变量可以只分配一次？".所以,根据这个文件:

除非在环境上下文中,否则Const声明必须具有初始值设定项

写入Const是错误的

const c = 0;
console.log(c); // OK: 0

c = 2; // Error
c++; // Error

{
    const c2 = 0;
    var c2 = 0; // not a redeclaration, as the var is hoisted out, but still a write to c2
}

而且,就目前而言(2015年11月)"const"在我看来是唯一的方式,由打字机开箱即用,以完成上述任务.

对于那些被贬低的人 - 如果你有另一个答案,请在这个帖子中与社区分享.

更新2:readonly

该只读修饰符(感谢@basarat)已打字稿2.0被引入.您可以在声明点或构造函数中初始化它们.

您甚至可以将类属性声明为只读.您可以在声明点或构造函数中初始化它们,如下所示:

class Foo {
    readonly bar = 1; // OK
    readonly baz: string;
    constructor() {
        this.baz = "hello";  // OK
    }
}

但正如在这个帖子中所说的@RReverser :

像往常一样,你需要使用npm i typescript @ next来获得包含实验性功能的最新编译器.

Answer 2

您可以使用方法装饰器并将描述符对象的可写属性设置为 false。

function final(target: Object, key: string | symbol, descriptor: PropertyDescriptor) {
  descriptor.writable = false;
}

然后在包含final方法的父类中使用装饰器。

class Parent {
  @final
  speak() {
    console.log('Parent speaking');
  }
}

如果您现在扩展 Parent 类并尝试覆盖它的speak方法，您将收到错误：

错误：“说话”是只读的

class Child extends Parent {
  // Error: "speak" is read-only
  speak() {
    console.log('Child speaking');
  }
}

通过使用装饰器，您可以通过一种非常具有描述性的方式将方法标记为最终方法。

工作示例

编辑：正如 Mark 指出的，这仅在转换为 ES5 或更早版本时才有效。

Answer 3

您可以使用 set/get 来实现结果。

class Test {

    constructor(public a: number, private _b: number) {}

    get b(): number {
        return this._b;
    }

}

var test = new Test(2, 1);

test.a = 5 //OK
test.b = 2 //Error

test.b 无法设置，因为它没有设置器。

TS 编译器不会就此发出警告，但浏览器会抛出错误。

Answer 4

没有final关键字，但您可以通过以下方式使用readonly：

分配一次

class IFACE {
    constructor(public a: number, readonly b: number) {}
}

let test: IFACE = new IFACE(1, 34);

 test.a = 5; // OK
// test.b = 2; // Error

console.log(test.a, test.b); // 5 34

禁用覆盖

class IFACE {
    constructor(public a: number, readonly b: number) {
        // console.log(`b is ${this.b}`);
        this.b = 2; // b is always 2
        // console.log(`b is ${this.b}`);
    }
}

let test: IFACE = new IFACE(1, 34);

test.a = 5;
console.log(test.a, test.b); // 5 2

不确定最后一个是否是一个错误，因为您两次分配给只读字段 - 一次在构造函数参数中，一次在构造函数主体中。

请注意，如果双重分配像我一样困扰您，您可以将最后一个更改为此：

class IFACE {
    a: number;
    readonly b: number = 2;

    constructor(a: number) { this.a = a; }
}