TypeScript进阶实战学习记录

https://www.tslang.cn/docs/handbook/basic-types.html

联合类型的一种类型

如何逃过类型约束，中间变量+{}块作用域

function f ( lianhe: OneClass | OneClass1 ) {
        const oneClass = lianhe;
        if ( oneClass instanceof OneClass ) {
            oneClass.teyoushuxing
        }

}

接口type<>使用

export interface BaseAction<RootStateManager extends BaseStateManager<{}>, ReturnValue extends void | Promise<void> = void> {
    (rootState: RootStateManager): ReturnValue;
}

type Action = BaseAction<RootStateManager>;

对象内部：keyof

protected onSet(key: keyof this) {
        if ((staticArry as Array<keyof this>).includes(key)) {
            this.invalidate();
        }
    }

私有变量

@trackableProperty
    private _size: Vector3d;
    set size(size: Vector3d) {
        this._size = size;
    }
    get size() {
        this.validate();
        return this._size;
    }

shli.size=

高级类型-Partial

type Partial<T> = {
    [properties in keyof T]?: T[properties];
};

类的修饰符

当成员被标记成 private时，它就不能在声明它的类的外部访问。

class Animal {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}

new Animal("Cat").name; // 错误: 'name' 是私有的.

TypeScript使用的是结构性类型系统。 当我们比较两种不同的类型时，并不在乎它们从何处而来，如果所有成员的类型都是兼容的，我们就认为它们的类型是兼容的。

然而，当我们比较带有 private或 protected成员的类型的时候，情况就不同了。 如果其中一个类型里包含一个 private成员，那么只有当另外一个类型中也存在这样一个 private成员， 并且它们都是来自同一处声明时，我们才认为这两个类型是兼容的。 对于 protected成员也使用这个规则。

class Animal {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}

class Rhino extends Animal {
    constructor() { super("Rhino"); }
}

class Employee {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}

let animal = new Animal("Goat");
let rhino = new Rhino();
let employee = new Employee("Bob");

animal = rhino;
animal = employee; // 错误: Animal 与 Employee 不兼容.

类的类型约束

：typeof BasePlugin 构造
： BasePlugin 类实例

new (onInitialize): BasePlugin;

类：一组对象从同一个原型对象继承属性
原型对象是类标识的基本：当仅当两个对象继承同一个原型对象，它们才是同一个类的实例

https://react.docschina.org/docs/portals.html