TS官方文档小记

1. TS修改ReadonlyArray

let a: ReadonlyArray<number> = [1, 2];

let b = a as number[];

b.push(3);

console.log(a);  // [1 ,2 ,3]
console.log(b);  // [1 ,2 ,3]

// 编译后
var a = [1, 2];
var b = a;
b.push(3);
console.log(a);
console.log(b);

• 类型断言只是绕开了编译上的报错，本质上并没有对赋值操作带来任何影响

2. 接口描述了类的公共部分，而不是公共和私有两部分。 它不会帮你检查类是否具有某些私有成员。

interface MyKlass {
    name: string;
    age: number;
}

// ERROR: Class 'Test' incorrectly implements interface 'MyKlass'.
//  Property 'age' is private in type 'Test' but not in type 'MyKlass'.
class Test implements MyKlass {  
    name: 'han';
    private age: 1
}

• 这个问题的报错有些奇怪，意思好像是让我们为类型也加一个private。但实际上接口并不能规定私有成员应该有的类型，不应该用这个interface来检查私有成员

3. 混合类型

• 一个对象可以同时做为函数和对象使用，并带有额外的属性。

interface Counter {
    (start: number): string;
    interval: number;
    reset(): void;
}

function getCounter(): Counter {
    let counter = <Counter>function (start: number) { };
    counter.interval = 123;
    counter.reset = function () { };
    return counter;
}

let c = getCounter();
c(10);
c.reset();
c.interval = 5.0;

4. 关于类

• 在我们声明一个类Test时，我们还同时声明了一个类型Test,所有该类的实例的类型都是Test

• typeof Test 与 Test区别： 类是有自己的类型的， 类的类型与实例的类型并不相同:

class Test {
    static age = 18;
    public name = 'gaarahan';
}

const testIns = new Test();

const instanceTypeTest: Test = testIns;
/* Property 'age' is a static member of type 'Test' */
console.log(instanceTypeTest.age);   // Error: Test 是实例的类型，实例上是访问不到静态属性的

/*
Type 'Test' is not assignable to type 'typeof Test'.
  Property 'prototype' is missing in type 'Test'.
*/
const klassTypeTest: typeof Test = testIns;  // 类的类型(typeof Test)与实例类型(Test)并不兼容

const klassTypeTest1: typeof Test = Test;  // typeof Test 与 Test 是兼容的
console.log(klassTypeTest1.age);  

• 类的类型就是构造函数的类型 ？

5. 显式的使用this以支持类型检查

interface ITest {
  name: string
}

class Test implements ITest {
    name: 'han';
    saySth(this: Test) {
        return () => {
          alert(this.name)
        }
    }
}

const t = new Test();
const saySth = t.saySth();

saySth();

• 在该例中，不为saySth传递this参数，函数也可以正常工作，但此时的this，会被推断为any类型，显式的传递this，可以使其支持类型检查。

6. 对于工厂函数来说，我们也可以检查传入构造函数的参数，来避免出错

class Clock {
    date: Date;
    constructor(date: Date) {
        this.date = date;
    }
}

function factoryWithoutType<T>(c): T {
    return new c('han');  // 使用错误的参数来初始化
}

function factoryWithType<T>(c: { new (name: string) }): T {
    return new c('han');   // 使用错误的参数来初始化
}

const clockHan1 = factoryWithoutType<Clock>(Clock);
console.log(clockHan1.date);  // 'han'

const clockHan2 = factoryWithType<Clock>(Clock); // 传入的参数类型检查报错

• 在没有类型检查时，工厂能够成功执行，但结果显然不是我们想要的东西（date 是一个无意义的 string）

7. const枚举 与 外部枚举

• const枚举并不会生成一个额外的变量，而是会在编译阶段将其变成常量写在代码中
• const枚举只能使用常量枚举表达式，不允许包含计算成员;
• const枚举不能使用反向映射。
• const枚举与普通枚举的编译对比：

// 编译前
const enum Enum {
    A = 1
}
console.log(Enum.A);
console.log(Enum[1]); // Error: A const enum member can only be accessed using a string literal.
// --------------------------------------

enum Test {
    A
}
console.log(Test.A);

// 编译后
console.log(1 /* A */);
console.log(Enum[1]);
// --------------------------------------
var Test;
(function (Test) {
    Test[Test["A"] = 0] = "A";
})(Test || (Test = {}));
console.log(Test.A);