typescript 虚函数-TypeScript 的异步函数

必须认识到setTimeout是一个异步函数。

由于TS中没有线程睡眠typescript 虚函数，所以我提供以下测试方法

一：正常

module demo{
    export class AsyncDemo{
        private _sentry : number = 0;
        public start() : void{
            this.getSomething("Aonaufly").then(
                $value=>{
                    egret.log(`执行成功 ! name : ${$value}`);
                },
                $error=>{
                    egret.log(`执行失败 ! error : ${$error}`);
                }
            );
        }
        private timeout() : number{
            while( this._sentry == 0 ){
                if( this._sentry != 0 ){
                    break;
                }
            }
            return egret.setTimeout(
                this.handler_timeout,
                this,
                2500
            );
        }
        /**
         * 测试异步回调函数
         * @param {string} $name
         */
        private async getSomething( $name : string ) : Promise{
            egret.log(`开始执行异步函数`);
            this._sentry = 1;
            const $id = await this.timeout();
            egret.log(`timeout 执行完毕! timeid : ${$id}`);
            return $name;
        }
        private handler_timeout() : void {
            egret.log(`执行了等待 2.5秒`);
        }
    }
}

结果：

说明：setTimeOut是异步的

二：

因为:await关键字在等待this.timeout()的结果，永远不会等待，所以程序卡住了

结果：

这和C#是一样的，只不过C#容易测试，因为C#有线程的概念！！！

其他补充：

以下是使用 Promomise 的三个示例

第一种情况使用newPromisetypescript 虚函数，凸显promise实现的异步机制

2和3使用Promise.resolve

第三种情况，参数通过then传递给下一个then

复制并运行代码，你会听到promise的奥秘

//new Promise() vs Promise.resolve()
//then 方法每次都会返回 promise实例对象
function newPromise_resolve() {
   return new Promise((resolve,reject) => {
      resolve(); //这里调resolve方法，则then方法会被调用
      console.log('resolve里面的log');
   })
   //先输出 resolve里面的log
   //后输出 then方法
   //这里很好地体现了 Promise实现了 node.js的异步机制
}
newPromise_resolve().then(() => {
   console.log('then方法');
});
newPromise_resolve();
//使用Promise.resolve
function promise_resolve() {
   let promise = Promise.resolve();
   promise
   .then(() => {
      console.log('promise_resolve1');
   })
   .then(() => {
      console.log('promise_resolve2');
   });
   return promise;
}
//promise_resolve(); 
function promise_forEach_then() {
   let ids = [1,2,3];
   let promise = Promise.resolve();
   ids.forEach((id) => {
      promise
      .then(() => {
         return {id}
      })
      .then(consoleLogId)
   });
}
function consoleLogId(id) {
   console.log('promise_forEach_then---' + id);
}
//promise_forEach_then();

///////////////////////////////////////////////////////////////////////

        public deatoryGroupRes( $groupName : string ) : Promise{
            if( this._hashmap.containsKey( $groupName ) == true ){
                if( this._is_loading == true && $groupName == this._cur_group ){
                    return new Promise((resolve,reject) : void=>{
                        resolve(false);
                                                reject(false);
                    });
                }else{
                    this._hashmap.remove( $groupName );
                    return RES.destroyRes( $groupName );
                }
            }else{
                return RES.destroyRes( $groupName );
            }
        }