typescript学习笔记（二）

类：

class Obj {
    move(){...}
}

继承：

class Father{
    move() {}
}
class Son extends father{
    run() {}
}
let man = new Father();
man.move();
man.run();

当子类和父类中有构造函数时，子类在调用this前必须执行super()，这句语句会执行基类的构造函数

public, private, protected:

public：当没有定义修饰符时默认为public，此时该属性或方法可以在基类和子类以及实例中被访问

private：该属性只能在被定义的类中被访问

protected：只可以在派生类中被访问，在实例中不能被访问（可以通过派生类中的方法访问）

readonly:

修饰属性为只读的，必须在声明中或者构造函数里被初始化

存取器：

typescript支持使用getters/setters来截取对对象成员的访问

let passcode = 'secret';
class Emloyee {
    private _fullName: string;
    get fullName () {
       return this._fullName;
    }
    set fullName (newName: string) {
       if(passcode && passcode == "secret") {
           this._fullName = newName;
       } else {
           console.log("error");
       }
    }
}

let employee = new Employee();
employee.fullName = 'bob';
if(employee.fullName){
    alert(employee.fullName);
}

静态属性：

static修饰的属性：这些属性存在于类本身上，而不是类的实例上，每个类的实例想要访问静态属性时，都需要在静态属性名称前加上类名

抽象类：

abstract：abstract用于定义抽象类或者在抽象类内部定义抽象方法。

抽象类作为其他派生类的基类使用，它们一般不会直接被实例化，不同于接口，抽象类可以包含成员的实现细节

注：抽象类中的抽象方法不包含具体的方法体，具体实现必须在派生类中实现

泛型：

如果希望传入数据类型与返回数据类型一致，但不定死，可以使用泛型

function identity<T> (arg: T): T {
    return arg;
}

T捕获到用户传入的类型（eg：number），之后我们就可以使用这个类型

let output = identity<string>("myString");

可以这样明确指定类型为String

let output = identity("myString");

也可以不明确指明类型，编译器会根据传入的参数自动确定T的类型

注：使用泛型一些属性的访问会收到影响

如果我们想要传入数组作为参数，并且在内部访问length属性，需要按以下方法：

function identity<T>(arg: T[]): T[]{
    // 此时可以访问arg.length
}

泛型接口：

interface fanInterface<T> {
   (arg: T): T;
}
function identity<T>(arg: T): T {
   return arg;
}
let haha: fanInterface<numebr> = identity;

泛型类：

class FanClass<T> {
    name: T;
    action: (x: T, y: T) => T;
}
let haha = new FanClass<string>();
haha.name = 'aaa';
haha.action = function(x, y) {return x + y;}

泛型约束：

约束即约束传入类型，也就是说传入的类型需要满足约束条件才可以传入

interface HasLength {
    length: number;
}
function arrayIdentity<T extends HasLength>(arg: T): T {
    // 传入参数一定有length属性
}

在泛型约束中使用类型参数：

如果传入的参数中有被其他参数约束，可以像下面这样：

function getProperty<T, K extends keyof T>(obj: T, key: K) {
    return obj[key];
}
let x = {a: 1, b: 2, c: 3};
getProperty(x, "a");    // 1