我对Promises的理解

本文作者就是我,简书的microkof。如果您觉得本文对您的工作有意义,产生了不可估量的价值,那么请您不吝打赏我,谢谢!

名词约定

Promises的概念是由CommonJS小组的成员在Promises/A规范中提出来的。一般来讲,有以下的名词约定:

promise(首字母小写)对象指的是Promise实例对象

Promise首字母大写且单数形式,表示Promise构造函数

Promises首字母大写且复数形式,用于指代Promises规范

Promises/A规范和ES6 Promises规范

Promise规范有几次升级,目前来讲,Promise/A是最新的民间规范,ES6 Promises是最新的官方规范,只需知道ES6 Promises规范是你应该遵守的标准就行了。

为什么有Promises这个东西

  1. 解决回调金字塔的问题,回调金字塔也叫回调圣诞树,好听吧?还有个别名叫回调地狱,不好听了吧?到底可怕不可怕?非常的可怕。
  2. 可以同时管理成功回调和失败回调。

名词解释:同步任务和异步任务

  • 同步任务:只需JS引擎自身就可以完成的任务,叫同步任务。
  • 异步任务:JS引擎自身无法完成,需要外力协助的任务,叫异步任务;还有一种是由JS引擎能够独立完成,但是JS引擎把任务分成了两段,第二段当做回调,也是异步任务。

简单理解JS引擎的执行机制的话,异步任务分为三个执行段,对JS引擎来讲是执行第一和第三个阶段:

  1. 异步任务本体执行:由JS引擎同步执行
  2. 异步任务外力执行:由外力执行
  3. 异步任务回调执行:由JS引擎异步执行

所谓“承诺”

Promise这个单词的意思是“承诺”,就是我们日常说的“我肯定帮你买早饭”、“你如果交了钱我肯定给你一杯咖啡”。

在程序世界,举例可以说:“我承诺给你完成这些代码执行”。new一个Promise实例,就是JS引擎对你做了一个承诺。

既然是承诺,就肯定有成功的时候有失败的时候,比如我帮你买早餐,结果今天煎饼果子没出摊,或者是我走到半路上,煎饼果子的塑料袋破裂,煎饼果子滑落到了地上,这就是失败。就连“我们承诺绝不首先动用核武器”都有坚持不下去的时候,所以只要是承诺就有成功和失败,只不过是概率问题。

到程序世界,一个承诺也会有三种状态,就是“未决的”、“成功的”、“失败的”三种状态。也就是pending/resolved/rejected三种状态。

Promise构造函数的超能力

Promises写法的本质就是把异步写法撸成同步写法。要做这么酷炫这么变态的事情,当然需要Promise构造函数有超能力,它的超能力就是传入Promise构造函数的函数参数会第一优先执行,无论这个函数多么的繁复,有多少层回调,有多少秒的计数器,统统都会最优先执行,也就是说,我们只要new了一个Promise(),那么Promise构造函数的函数参数其实是同步代码,但是.then比较特殊,.then会等到promise对象实例有了结果(resolved或者rejected),.then()里面代码才会执行。链条上的每一个.then都会等前面的promise有了结果才会执行,Promise构造函数的这个超能力是Promises系统的威力之源。(当然,这里说的执行优先级,是在理想环境下,所谓理想环境也就是全部执行代码只由new Promise()和它的一系列.then()方法组成。如果方法链之外还有其他代码,那么整体代码执行的先后顺序就复杂化了,涉及到ES最底层的Event Loop,下文有介绍。然而,Promise加它的then方法链已经提供了梳理代码执行顺序的整套方案,如果在方法链之外还写异步代码的话属于不鼓励的写法,应该尽量避免这么做。)

实现了Promise/A规范的浏览器

简单说,IE全不支持,Edge支持,Chrome和Firefox在十几个版本之前就已经接近支持,目前的最新版已经全面支持。

所以,IE8-10可以考虑Promise/A的Polyfill库:

jakearchibald/es6-promise
一个兼容 ES6 Promises 的Polyfill类库。 它基于 RSVP.js 这个兼容 Promises/A+ 的类库, 它只是 RSVP.js 的一个子集,只实现了Promises 规定的 API。

yahoo/ypromise
这是一个独立版本的 YUI 的 Promise Polyfill,具有和 ES6 Promises 的兼容性。 本书的示例代码也都是基于这个 ypromise 的 Polyfill 来在线运行的。

getify/native-promise-only
以作为ES6 Promises的polyfill为目的的类库 它严格按照ES6 Promises的规范设计,没有添加在规范中没有定义的功能。 如果运行环境有原生的Promise支持的话,则优先使用原生的Promise支持。

其他还有很多Polyfill类库,不多说,可以github一下。

基本用法

案例1:现在开始,延迟3秒,执行console.log('第一个回调'),然后定义一个变量a,值是3,然后再延迟2秒,执行console.log('第二个回调'),然后执行console.log(a * 2)。回调圣诞树型写法是:

setTimeout(function() {
    console.log('第一个回调');
    var a = 3;
    setTimeout(function() {
        console.log('第二个回调');
        console.log(a * 2);
    }, 2000);
}, 3000);

执行上面代码,结果是:先延迟3秒,然后浏览器打印了一个第一个回调字符串,然后又延迟2秒,然后浏览器打印了一个第二个回调字符串,以及打印了一个6数字。

然后遵循Promises的写法是:

var promise = new Promise(function(resolve, reject) {
    setTimeout(function() {
        console.log('第一个回调');
        var a = 3;
        if ( true ){
            resolve(a);
        } else {
            reject('bu ok');
        }
    }, 3000);
});

promise.then(function(value) {
    setTimeout(function() {
        console.log('第二个回调');
        console.log(value * 2);
    }, 2000);
}, function(error) {
      console.log(error);
});

执行结果跟圣诞树写法的结果完全一致。

Promise是一个构造函数,用来生成promise实例。Promise构造函数接受一个函数作为参数,该函数的两个参数分别是resolve和reject。它们是两个函数,由JavaScript引擎提供,不用自己部署。

promise对象代表一个异步操作,有三种状态:Pending(进行中)、Resolved
(已完成)和Rejected(已失败)。

  • resolve函数的作用是,将promise对象的状态从“未完成”变为“成功”(即从Pending变为Resolved),在异步操作成功时调用,并将异步操作的结果,作为参数传递出去。
  • reject函数的作用是,将promise对象的状态从“未完成”变为“失败”(即从Pending变为Rejected),在异步操作失败时调用,并将异步操作报出的错误,作为参数传递出去。

promise对象生成以后,可以用then方法分别指定Resolved状态和Reject状态的回调函数。

then方法可以接受两个回调函数作为参数。第一个回调函数是promise对象的状态变为Resolved时调用,第二个回调函数是promise对象的状态变为Reject时调用。其中,第二个函数是可选的,不一定要提供。这两个函数都接受promise对象传出的值作为参数。

然后这里你可能会问,if ( true ){}是什么鬼?因为console.log('第一个对象');var a = 3;是不可能失败的,这都能失败的话,等于js引擎挂了,也等于页面挂了。所以我只能模拟成功和失败状态,现在你把true改成false试试,那么,延迟2秒之后是不是打印了bu ok

比较两种写法的区别,首先就可以看出Promises写法的代码多了很多。如果你确定promise对象根本不可能有失败的状态,可以省掉reject函数以及错误回调。那么可以简写成这样:

var promise = new Promise(function(resolve) {
    setTimeout(function() {
        console.log('第一个回调');
        resolve(3);
    }, 3000);
});

promise.then(function(value) {
    setTimeout(function() {
        console.log('第二个回调');
        console.log(value * 2);
    }, 2000);
});

上面代码就是只考虑promise对象“成功”的可能性,不考虑失败的可能性。

去掉promise对象失败的可能性之后,你可能继续会说,“Promises写法的代码还是多!”没错,确实多,但不要只看劣势不看优势,没有优势的东西,是没人会用的。假设回调多起来了,比如至少5个,而且每一步回调都有成功和失败状态,那么Promises的优势才能显现出来。

案例2:在案例1的基础上,再延迟1秒,执行console.log('第三个回调'); console.log(value * 2);,也就是说,我想在第二步的输出值的基础上再乘以2,也就是想得到12。代码如下:

var promise = new Promise(function(resolve, reject) {
    setTimeout(function() {
        console.log('第一个回调');
        resolve(3);
    }, 3000);
});

promise.then(function(value) {
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            console.log('第二个回调');
            console.log(value * 2);
            resolve(value * 2);
        }, 2000);
    });
}).then(function(value) {
    setTimeout(function() {
        console.log('第三个回调');
        console.log(value * 2);
    }, 1000);
});

结果没问题:

Paste_Image.png

这里用到了then的链式调用。你会发现第一个then返回了一个promise对象。这就跟案例1不一样了,案例一的then里没有再返回promise对象。必须返回么?看案例3。

案例3:跟案例2相似,只是执行console.log('第二个回调')这步不用延迟。代码如下:

var promise = new Promise(function(resolve, reject) {
    setTimeout(function() {
        console.log('第一个回调');
        resolve(3);
    }, 3000);
});

promise.then(function(value) {
    console.log('第二个回调');
    console.log(value * 2);
    return value * 2;
}).then(function(value) {
    setTimeout(function() {
        console.log('第三个回调');
        console.log(value * 2);
    }, 1000);
});

跟案例2的代码的区别是什么?第一个then方法中,没了return promise对象,取而代之的是return value * 2,为什么?

因为案例2中,三个then的回调函数是异步-异步-异步,案例3中,是异步-同步-异步,这区别很大。简单情况下,then方法中的回调执行代码是同步代码,这样只需要简单return一下参数,就可以把参数传递下去。复杂情况下,是异步-异步-异步这种情况,如果依然简单的在setTimeout的回调里return一下参数,你会发现,参数根本没有及时传递。代码如下:

var promise = new Promise(function(resolve, reject) {
    setTimeout(function() {
        console.log('第一个回调');
        resolve(3);
    }, 3000);
});

promise.then(function(value) {
    setTimeout(function() {
        console.log('第二个回调');
        console.log(value * 2);
        return value * 2;
    }, 2000);
}).then(function(value) {
    setTimeout(function() {
        console.log('第三个回调');
        console.log(value * 2);
    }, 1000);
});

结果就神奇了:

Paste_Image.png

什么原因?怎么理解?

简单说原因是:

then的链式执行,理想情况下是基于每个then的前一个then能够返回promise对象。不理想情况下是没有返回promise对象,这种情况下,虽然then的链式执行依然可以执行,但是,每个then只可能等前一个then同步代码完成,不会等前一个then异步代码完成。第一个then的同步代码是一个计时器,开始计时就算完成了,然后第二个then什么也没得到,其实是得到了一个undefinedundefined * 2得到NaN,所以打印NaN

为啥第一个then的回调用return promise对象,第二个then就可以等那2秒的延迟呢?用上段文字就很好理解了,而且你还可以回忆一下本文最上方说的promise对象的超能力,当你给then返回一个非promise对象,then只接收同步的返回值,反之,当你给then返回一个promise对象,那么then就等待promise对象生成,然后等resolvereject传递参数,等多久都能等。

这里要注意一下,我上段文字所说的“等待”,其实并不是等待,而是new一个promise对象的过程被js引擎视为同步任务执行,因此new出了promise对象,并return的过程,其实是同步代码,then其实并不是在等待,而是非常自然的链式执行顺序。

为什么第三个回调比第二个回调先执行了?因为第二个then得到了undefined之后,第三个then就开始了,第三个回调延迟的时间短嘛,就1秒,所以比第二个回调先执行了。

为啥“第二个回调”下面输出是6?因为3 * 2得6。

总之,如果想异步-异步-异步-异步......这样一直搞下去,就只能是每一步都给下一步返回一个promise对象。

解答几个问题:

如果resolvereject语句后面还写了语句,会执行吗?

会。resolvereject负责传参,但不是说传了参就中止执行了。

如果第一个then的回调用了promise对象,但是promise对象没写resolvereject方法,第二个then的回调还会执行么?

答案是不执行,等于第二个then白写了,因为promise对象永远处于Pending状态。如果后面有第三个then,依然不会执行。等于链条从第一个promise对象就断了。

如果有resolvereject方法,但是不设参数,也就是resolve()reject(),那么then会执行吗?

会。resolvereject传的参数是undefined

如果第一个then的第一个回调函数没执行,第二个then的第一个回调函数会执行么?

会。第二个then的第一个回调,并不是前一个then的第一个回调的继承。

每个then的2个回调,只可能有其中一个回调执行。下一个then的第一个回调,只会看前一个then的任意回调是否返回成功的promise;下一个then的第二个回调,只会看前一个then的任意回调是否返回失败的promise。

如果promise只执行了reject方法,但第一个then没有写对应的error处理回调,第二个then写了,还能处理么?

能。Promises规定,参数可以无限制的顺着链条传递下去直到被处理掉。

如果流程是异步-同步-同步-同步.....这么走下去,那么搞一串then还有意义吗?所有同步合在一起岂不是更容易编写?也容易理解?

答案:如果真的是一串的同步,当然可以合并了。Promises的用武之地在于全异步或者异步-同步互相夹杂的情况。

then的回调的优先级有多高?

测试一下:

console.log('sync1');

setTimeout(function() {console.log('setTimeout1')}, 0);

var promise = new Promise(function(resolve, reject) {
    setTimeout(function() {console.log('setTimeoutPromise')}, 0);
    console.log('promise');
    resolve();
});

promise.then(function() {
    setTimeout(function() {console.log('setTimeoutThen-1')}, 0);
    console.log('then-1');
}).then(function() {
    setTimeout(function() {console.log('setTimeoutThen-2')}, 0);
    console.log('then-2');
});

setTimeout(function() {console.log('setTimeout2')}, 0);

console.log('sync2');

会得到

sync1
promise
sync2
then-1
then-2
setTimeout1
setTimeoutPromise
setTimeout2
setTimeoutThen-1
setTimeoutThen-2

这里就要科普一下ES的Event Loop,Event Loop简单说就是ES为了高效解决异步任务而制定的一套规则,它的基本含义这里不讲,可以自行网上搜索,也可以参考https://segmentfault.com/a/1190000016278115这篇文章,这里只摘抄结论:

ES的引擎里有2个队列:

一个叫宏队列,macrotask,也叫tasks。 一些异步任务的回调会依次进入macro task queue,等待后续被调用,这些异步任务包括:

  • setTimeout
  • setInterval
  • setImmediate (Node独有)
  • requestAnimationFrame (浏览器独有)
  • I/O
  • UI rendering (浏览器独有)

另一个叫微队列,microtask,也叫jobs。 另一些异步任务的回调会依次进入micro task queue,等待后续被调用,这些异步任务包括:

  • process.nextTick (Node独有)
  • Promise
  • Object.observe
  • MutationObserver

那么,ES整个的任务队列的执行机制就是:

  1. 执行全局Script同步代码,这些同步代码有一些是同步语句,有一些是异步语句(比如setTimeout等);
  2. 全局Script代码执行完毕后,调用栈Stack会清空;
  3. 从微队列microtask queue中取出位于队首的回调任务,放入调用栈Stack中执行,执行完后microtask queue长度减1;
  4. 继续取出位于队首的任务,放入调用栈Stack中执行,以此类推,直到直到把microtask queue中的所有任务都执行完毕。注意,如果在执行microtask的过程中,又产生了microtask,那么会加入到队列的末尾,也会在这个周期被调用执行;
  5. microtask queue中的所有任务都执行完毕,此时microtask queue为空队列,调用栈Stack也为空;
  6. 取出宏队列macrotask queue中位于队首的任务,放入Stack中执行;
  7. 执行完毕后,调用栈Stack为空;
  8. 重复第3-7个步骤;
  9. 重复第3-7个步骤;
    ......

看到了吧,结论是什么?结论是:微队列全部执行完,才执行宏队列的第一个任务,执行完宏队列的第一个任务之后,又去查看微队列是否有任务,如果有,则全部执行,然后再看宏队列的第一个任务。(宏队列说:卧槽,歧视我?)

结合到现在的例子,new Promise()的内容是同步代码,.then()是异步的,而且是微队列的,优先级高,setTimeout属于宏队列的,优先级低。.then方法的回调里面的同步任务,优先级肯定比new Promise()外面的setTimeout任务的优先级;而.then方法的回调里面的setTimeout任务,在宏队列里面没有排第一,所以优先级比new Promise()外面的setTimeout任务的优先级,因为外面的setTimeout任务在宏队列里排第一。

所以,从p对象赋值语句开始,JS引擎的执行顺序是:

new Promise()内的同步任务
-> 外部下方的同步任务
-> .then链里的所有回调里的同步任务
-> 外部的宏队列任务的回调,加上new Promise()内的宏队列任务的回调,按回调时间依次执行,如果时间一致,按照书写顺序定
-> .then链里的所有回调里的回调任务

由此可以看出,如果在then链条之外还写代码的话,优先级会比较混乱,就像本文开头说的,在then链条外面写代码不是一个好主意,应该由new Promise()和then链条统一管理本次需要执行的所有代码,否则优先级不容易把控。

Promise.prototype.catch()

.catch()是什么?它是.then()的一个子集,也就是说专用于接收promise对象的reject()传过来的error参数的。其他没什么特别的。也就是说,.then()可以有两个回调函数,.catch()只有一个回调函数。永远尽量在能用.catch()的场合全用.catch()

.catch()可以链式调用么?

可以。

可以跟.then()混合链式么?

可以。

如果上一层的.then()没有reject,.catch()会执行吗?

不会,会被JS引擎跳过。

.catch()下一层如果是.then(),会执行吗?

会。

参数怎么传递?

这个then接收的参数是上一个then传递的值,跟上一层的catch无关。也就是说,引擎跳过不执行的代码,该怎么传递就怎么传递。

连写.catch().then(//只写一个回调)是并列关系么?

绝对不是,是执行的前后关系。从来没有什么并列关系,只有连续的或者跳跃的前后关系。连写.then(//只写一个回调).catch()也不是并列关系。

Promise.all()

Promise.all方法用于将多个promise实例,包装成一个新的promise实例。

Promise.all()方法接受一个数组作为参数,p1、p2、p3都是Promise对象的实例,如果不是,就会先调用下面讲到的Promise.resolve方法,将参数转为Promise实例,再进一步处理。(Promise.all()方法的参数可以不是数组,但必须具有Iterator接口,且返回的每个成员都是Promise实例。)

p的状态由p1、p2、p3决定,分成两种情况。

  1. 只有p1、p2、p3的状态都变成fulfilled,p的状态才会变成fulfilled,此时p1、p2、p3的返回值组成一个数组,传递给p的回调函数。
    注意,如果p1的最后一个then的回调没有return命令,那么p1的返回值就是undefined,即使倒数第二个then的回调有返回值也没有用,只看最后一个then的回调的返回值。
    再注意,组成的数组的顺序是按照.all()参数的书写顺序而定,跟谁先返回值无关。
  2. 只要p1、p2、p3之中有一个被rejected,p的状态就变成rejected,此时第一个被reject的实例的返回值,会传递给p的回调函数。

下面是一个具体的例子。

var p1 = new Promise(function(resolve, reject) {
    setTimeout(function() {
        console.log('第一个回调');
        reject(3);
    }, 3000);
});

var p2 = new Promise(function(resolve, reject) {
    setTimeout(function() {
        console.log('第二个回调');
        reject(2);
    }, 2000);
});

Promise.all([p1, p2]).catch(function(value) {
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            console.log('第三个回调');
            resolve(value * 2);
            console.log(value * 2);
        }, 2000);
    });
}).then(function(value) {
    setTimeout(function() {
        console.log('第四个回调');
        console.log(value * 2);
    }, 1000);
});

结果是下图。由于p1和p2都rejected,所以catch捕获的参数是p2传过来的,因为p2的延迟比p1短。

Paste_Image.png

如果p1的回调是同步任务,p2是异步任务,毫无疑问,catch捕获的参数会是p1传过来的,但是,通常肯定不这么用,这么写太蠢了。如果p1和p2都是同步任务?更蠢,那么你干嘛不把p1和p2写到一起呢?而且,根本不需要Promises写法。

如果p1和p2都fulfilled,那么value是一个数组。不代码举例了。

总结:Promise.all()方法的适用场合,是多个异步任务并发执行,在最后一个任务成功完成之后,给出一个回调。比如,并发10个xhr线程,传10个文件,你并不知道哪个文件会先传完,Promise.all()方法能确保在10个文件都传完的那一刻给出完成提示。

如果不用Promise.all()方法,通常做法是设一个计数器初始值为0,每上传成功一个文件就+1,然后判断一次,看看计数器是否等于10,如果等于的话,就给出完成提示。最终相当于判断10次。

Promise.race()

Promise.race方法同样是将多个Promise实例,包装成一个新的Promise实例。

var p = Promise.race([p1,p2,p3]);

上面代码中,只要p1、p2、p3之中有一个实例率先改变状态,p的状态就跟着改变。那个率先改变的Promise实例的返回值,就传递给p的回调函数。

注意,所谓率先改变状态,可能会改成fulfilled,也可能会改成rejected,都可以。

Promise.race方法的参数与Promise.all方法一样,如果不是Promise实例,就会先调用下面讲到的Promise.resolve方法,将参数转为Promise实例,再进一步处理。

Promise.race的使用场合不算常见,比如一款小游戏,三辆赛车比赛,任何一个车先到达终点,比赛就结束,那么可以适用于Promise.race。或者是一个躲开障碍的游戏,任何一个障碍物撞到你,游戏就结束,那么可以适用于Promise.race。

还一个场合是超时判定。比如一个ajax请求,30秒下载不下来就算失败。这样,p1是ajax请求,p2是30秒计数器,谁先完成,p的状态就随谁。那个率先改变的Promise实例的返回值,就传递给p的回调函数。

Promise.resolve()

有时需要将现有对象转为Promise对象,Promise.resolve方法就起到这个作用。

var jsPromise = Promise.resolve($.ajax('/whatever.json'));

上面代码将jQuery生成的deferred对象,转为一个新的Promise对象。

Promise.resolve方法的参数分成四种情况。

(1)参数是一个Promise实例

如果参数是Promise实例,那么Promise.resolve将不做任何修改、原封不动地返回这个实例。

(2)参数是一个thenable对象
thenable对象指的是具有then方法的对象,比如下面这个对象。

var thenable = {
    then: function(resolve, reject) {
        resolve(42);
    }
};

var jsPromise = Promise.resolve(thenable);

jsPromise.then(function(value) {
    console.log(value);  // 42
});

(3)参数不是具有then方法的对象,或根本就不是对象
如果参数是一个原始值,或者是一个不具有then方法的对象,则Promise.resolve方法返回一个新的Promise对象,状态为Resolved,实例p向then的回调函数传的参数就是那个原始值。

var p = Promise.resolve('Hello');

p.then(function (s){
      console.log(s) // Hello
});

上面代码生成一个新的Promise对象的实例p。由于字符串Hello不属于异步操作(判断方法是它不是具有then方法的对象),返回Promise实例的状态从一生成就是Resolved,所以回调函数会立即执行。Promise.resolve()方法的参数,会同时传给回调函数。

(4)不带有任何参数
Promise.resolve()方法允许调用时不带参数,直接返回一个Resolved状态的Promise对象。实例p向then的回调函数传的参数是undefined

所以,如果希望得到一个Promise对象,比较方便的方法就是直接调用Promise.resolve()方法。

var p = Promise.resolve();

p.then(function (s){
  console.log(1)
});

console.log(2);

上面代码的变量p就是一个Promise对象。

Promise.reject()

Promise.reject()方法也会返回一个新的promise实例,该实例的状态为rejected
。它的参数用法与Promise.resolve()方法完全一致。

最佳实践

现在Promises规范全部介绍完了。然后就是最佳实践。

参考文档:

promises 很酷,但很多人并没有理解就在用了

打开Promise的正确姿势

本文作者就是我,简书的microkof。如果您觉得本文对您的工作有意义,产生了不可估量的价值,那么请您不吝打赏我,谢谢!

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 203,456评论 5 477
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 85,370评论 2 381
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 150,337评论 0 337
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 54,583评论 1 273
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 63,596评论 5 365
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 48,572评论 1 281
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 37,936评论 3 395
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 36,595评论 0 258
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 40,850评论 1 297
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,601评论 2 321
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,685评论 1 329
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 33,371评论 4 318
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 38,951评论 3 307
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,934评论 0 19
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,167评论 1 259
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 43,636评论 2 349
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 42,411评论 2 342

推荐阅读更多精彩内容

  • 本文适用的读者 本文写给有一定Promise使用经验的人,如果你还没有使用过Promise,这篇文章可能不适合你,...
    HZ充电大喵阅读 7,293评论 6 19
  • 你不知道JS:异步 第三章:Promises 在第二章,我们指出了采用回调来表达异步和管理并发时的两种主要不足:缺...
    purple_force阅读 2,046评论 0 4
  • Promiese 简单说就是一个容器,里面保存着某个未来才会结束的事件(通常是一个异步操作)的结果,语法上说,Pr...
    雨飞飞雨阅读 3,348评论 0 19
  • 00、前言Promise 是异步编程的一种解决方案,比传统的解决方案——回调函数和事件——更合理和更强大。它由社区...
    夜幕小草阅读 2,126评论 0 12
  • 青砖黛瓦不解忧,缓带轻裘只影走。忍泪回首前尘秋。 寒山几度月如钩,红笺小字不诉愁。缦纱倩影上心头。
    此去昔年入梦阅读 412评论 2 2