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,所有该类的实例的类型都是Testtypeof 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);
