day0513

day0513

Promise

promise 和async、await

阻塞式同步

async异步函数自动返回一个promise

async 函数中await可以等待的前提条件有两个
1.必须再async函数，当前这个函数必须是async函数
2.await后面函数返回的内容必须是promise

事件循环eventloop

同步任务：微任务 宏任务
异步任务

宏任务 setTimeout setInterval
微任务 Promise
先执行同步任务,遇到微任务时,将其放在当前任务列的最底端,
遇到宏任务则会开辟一个新任务列,并且放在任务列的最顶端

typescript

public 当前类，子类和实例化都可以调用这个属性和方法，也可以覆盖
protected 当前和子类可以调用这个属性和方法，也可以覆盖，实例化对象不能调用
private 当前类可以使用这个方法和属性，子类和实例化对象不能调用

在父类中定义的私有方法，在子类中不可以重复实现，也不可以调用

抽象类是不能实例化的，只能被继承
抽象类是具备接口和类的特征，抽象属性和方法在继承后可以灵活定义
/非抽象属性和方法可以处理共有的逻辑内容

面向对象封装事件抛发

导入不加.ts扩展名
EmitterEvent.ts:

import EmitterTarget from "./EmitterTarget";

export default class EmitterEvent{
    public target:EmitterTarget|null=null;
    public currentTarget:EmitterTarget|null=null;
    public type:string;
    [key:string]:number|string|boolean|object|null;
    constructor(type:string){
        this.type=type;
    }
}

EmitterTarget.ts:

import EmitterEvent from "./EmitterEvent";
interface IEventDic{
    [key:string]:Array<Function|null>;
}
export default class EmitterTarget{
    private eventDic:IEventDic={};
    constructor(){

    }
    public addEventListener(type:string,listener:Function):void
    {
        if(this.eventDic[type] && this.eventDic[type].indexOf(listener)>-1) return;
        if(!this.eventDic[type])this.eventDic[type]=[];
        this.eventDic[type].push(listener);
    }
    public removeEventListener(type:string,listener:Function):void
    {
        var index=this.eventDic[type].indexOf(listener);
        if(!this.eventDic[type] || index===-1) return;
        this.eventDic[type][index]=null;
        this.eventDic[type].splice(index,1);
    }
    public dispatchEvent(evt:EmitterEvent):void
    {
        if(!this.eventDic[evt.type] || this.eventDic[evt.type].length===0) return;
        evt.currentTarget=this;
        evt.target=this;
        for(var i=0;i<this.eventDic[evt.type].length;i++){
            (this.eventDic[evt.type][i] as Function).call(this,evt);
        }
    }
}

Main.ts:

// var target=new EventTarget();
// target.addEventListener("chilema",chilemanHandler);

import EmitterEvent from "./EmitterEvent";
import EmitterTarget from "./EmitterTarget";

// var evt=new Event("chilema");

// target.dispatchEvent(evt);

// function chilemanHandler(e:Event){
//     console.log(e.type,"aaaa");
// }

var target:EmitterTarget=new EmitterTarget();
target.addEventListener("chilema",chilemaHandler);

var evt:EmitterEvent=new EmitterEvent("chilema");
evt.a=10;
target.dispatchEvent(evt);


function chilemaHandler(e:EmitterEvent){
    console.log(e.type,"aaaa",e.a);
}