es6 promise,ES6中的Promise.resolve到底有何作用

es6 promise,ES6中的Promise.resolve到底有何作用详细介绍

本文目录一览： 这段es6 JavaScript代码应该怎么理解呢？关于promise的

这段代码主要涉及 Promise 的链式调用。在创建 Promise 对象时，我们可以通过 `then()` 方法来指定当 Promise 状态变为 resolved（完成）时所执行的回调函数。同时，`then()` 方法还可以返回一个新的 Promise 对象，以支持链式调用。
在这段代码中，首先创建一个 Promise 对象 p1，并在其内部通过 `resolve()` 方法将 Promise 状态设置为 resolved，返回值为数字 1。然后在 p1 上链式调用 `then()` 方法，设置当 p1 完成时所执行的回调函数。在该回调函数中，通过调用 `p2()` 方法并将 p1 的返回值作为参数传递给它，返回一个新的 Promise 对象，再将该 Promise 对象上链式调用 `then()` 方法，继续设置回调函数。
但是，在这段代码中缺少了对 `p2()` 方法返回的 Promise 对象的处理。如果 `p2()` 方法返回的 Promise 对象被忽略了，那么整个链条就会被打破，导致后续的 `then()` 方法无法被正确地链接起来。这也就意味着 `p3()` 和 `p4()` 方法会同时执行，而不是在 `p2()` 完成后再依次执行。
因此，为了确保 Promise 链的正确执行，应该总是在每个 `then()` 方法中返回 Promise 对象，或者在某些情况下通过 `catch()` 方法终止链条的执行。
这段代码包含了Promise相关的ES6语法。Promise是一种解决异步编程问题的方案，是ES6中新增的一个重要特性。
这段代码包含了一个Promise，在Promise内部包含了一个异步操作（setTimeout方法）。当Promise对象被创建时，异步操作会被立刻执行。在异步操作完成之后，Promise对象的状态将会改变，从而触发Promise对象的resolve或reject回调函数，这取决于异步操作的结果。
在代码中，我们看到了resolve和reject两个函数。resolve表示异步操作成功，返回操作结果值；reject表示异步操作失败，返回错误信息。当异步操作完成之后，根据异步操作的结果，我们会手动调用其中某一个回调函数。
该Promise对象的状态一旦变为"resolved"或"rejected"，就会保持这个状态，不再变化。当Promise状态发生变化时，Promise.then()方法绑定的回调函数都会被调用，而Promise.catch()方法绑定的回调函数仅在Promise状态变为rejected时被调用。
总的来说，这段代码通过Promise对象语法，对异步操作的完成状态进行了如下处理：
1. 当异步操作成功完成时，Promise对象的状态变为"resolved"，并调用Promise的resolve方法返回操作结果值。
2. 当异步操作失败或出错时，Promise对象的状态变为"rejected"，并调用Promise的reject方法返回错误信息。
3. 在Promise then()方法绑定的回调函数中，用于处理异步操作返回的结果值。
这种异步编程模式可读性强、易于维护，大大提高了代码质量和可靠性。
你这代码不完整啊，题目意思也没说清楚。
你 p2 p3 p4 是怎么定义的？
具体是想要实现什么效果？
这段 ES6 JavaScript 代码展示了一个关于 Promise 链的例子。在这个例子中，一个简单的错误导致了 Promise 链的中断，使得 p4 与 p2 和 p3 同时进行。让我们先理解这段代码。
首先，创建了一个名为 p1 的新 Promise，并立即将其解析为值 1。然后，在 p1 的 then 方法中，我们调用了一个名为 p2 的函数，该函数返回一个新的 Promise。然后，我们又在 p2 的 then 方法中调用了名为 p3 的函数，该函数同样返回一个新的 Promise。最后，我们调用了名为 p4 的函数。
问题在于，这个代码中的 then 方法并没有正确地返回新的 Promise。在 p1 的第一个 then 方法中，我们应该返回 p2(result).then(newResult => p3(newResult))，这样 p4 才会在 p2 和 p3 完成后执行。由于我们没有返回这个新的 Promise，p4 实际上与 p2 和 p3 同时进行，而不是等待它们完成。
为了修复这个问题，我们需要确保在 p1 的第一个 then 方法中返回新的 Promise。这是一个修改后的代码示例：
现在，由于我们在 p1 的第一个 then 方法中返回了新的 Promise，p4 将等待 p2 和 p3 完成后再执行，从而保持了 Promise 链的完整性。

利用ES6的Promise.all实现至少请求多长时间的实例

1、背景我们都知道ajax请求可以加个timeout，就是最多请求多少时间，如果超过这个时间直接就报错。 这个是最多请求多长时间，我现在要做的是，最少要请求多长时间，然后才能执行后续的逻辑。比如，一个ajax请求 x 毫秒就执行完毕了，但我要让他至少执行1秒钟，那我们会这么想： ajax完成后 ， 1. 如果x<1s, 那我们先setTimeout => 1s - x ，然后执行后续操作。 2 如果x>=1s, 那我们直接执行后续操作。 想想这可繁琐了，我们还要在前面记录一下开始时间，后面记录一下结束时间，然后才能得到x。。或者变量flag，ajax里面完成设置flag，setTimeout里面完成也设置flag等等等方法，都很繁琐、2、Solution现在ES6有个Promise.all，非常适合解决此类问题。直接这样 Promise.all([ajaxPromise(), waitPromise(1s)]).then(()=> 至少执行了1s) 。。如果说是 多个ajax（promise）按顺序执行，但总共加起来的时间至少是1s呢？ 那就用一个Promise把多个ajax包起来。然后 Promise.all([ajaxPromiseAll(), waitPromise(1s)]).then(()=> 至少执行了1s) 。。3、 讲得很抽象，实例为证这个实例是这样的，微信里面有拆红包，当我们点击 _ 的时候，那个字至少会完整的 翻一翻。那个完整翻一翻的时间我们假定需要1秒钟。 如果我们直接点击开的时候，立即请求ajax，等ajax完成立即拆开红包，这里的时间 有可能不足1s，那 就不能做到完整翻一翻。 如果请求大于1s，那就让它一直翻转吧，直到完成请求。所以我们为了解决这个问题，就需要用到上面的技术。参考代码如下(Chrome最新版下测试)：/ ajax模拟Aconst funcA = async () => new Promise(resovel => { setTimeout(() => { console.log("done A"); resovel("func A"); }, 400); });因为async和await使用起来比Promise爽，所以我采用了这两个语法糖来写，用setTimeout来模拟ajax请求, ajax模拟A和 ajax模拟B有顺序关系的，比如先检测这个人是否还有机会打开红包，然后再请求打开红包获得随机红包金额 。以上这篇利用ES6的Promise.all实现至少请求多长时间的实例就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。

Promise知识点总结

promise 是 es6 的特性，现代主流浏览器基本上都已经支持，可以放心使用了。

promise 对象代表一个异步操作，具有3中状态：
1、pending ：初始状态。
2、resolve：操作成功的状态。
3、reject：操作失败的状态。

创建 promise 对象后，会立即执行，其状态为 pending ；执行之后只有2中结果：执行成功会变成 resolve 状态，执行失败会执行 reject 状态。
promise 的状态是无法获取的，它是内部变量。但可以在控制台的输出可以看见：

而且该状态也不需要获取，因为promise一旦建立，就会执行，而且该执行过程是不可以取消的，所以执行结果始终都会在promise.then()或者promise.catch()方法中出现。

promise 的优缺点：
优点：
1、将异步操作以同步操作的方式表达出来，避免层层嵌套回调函数
2、提供统一的操作接口，方便对异步操作的控制
缺点：
1、promise一旦建立，则不可取消
2、如果不设置回调函数，则会在promise内部抛出错误，不会反应到外部
3、当状态是pending是，无法判断当前状态（是异步刚刚开始执行还是即将完成了异步操作）

promise 的用法：
创建一个 promise 对象

例子：

promise 相关API：
1、promise.then(onFulfilled, onRejected) 或者 promise.then(onFulfilled).catch(onRejected) 这两个写法是等价的，都是执行promise执行成功和失败的处理
2、promise.then、promise.catch、promise.finally 的链式操作
promise.prototype.then 方法返回的是一个新的 Promise 对象，因此可以采用链式写法。
例子：

3、promise.all(iterable)
这个方法返回一个新的promise对象，该promise对象在iterable参数对象里所有的promise对象都成功的时候才会触发成功，一旦有任何一个iterable里面的promise对象失败则立即触发该promise对象的失败。
4、promise.allSettled(iterable)
等到所有promises都已敲定（settled）（每个promise都已兑现（fulfilled）或已拒绝（rejected））。
返回一个promise，该promise在所有promise完成后完成。并带有一个对象数组，每个对象对应每个promise的结果。
5、promise.any(iterable)
接收一个Promise对象的集合，当其中的一个 promise 成功，就返回那个成功的promise的值。
6、promise.race(iterable)
当iterable参数里的任意一个子promise被成功或失败后，父promise马上也会用子promise的成功返回值或失败详情作为参数调用父promise绑定的相应句柄，并返回该promise对象。
7、promise.resolve(value)
返回一个状态由给定value决定的Promise对象。
例如：

8、promise.reject(reason)
返回一个状态为失败的Promise对象，并将给定的失败信息传递给对应的处理方法
例子：

es6 promise的catch 和 then 的区别认识

catch 返回实值：Promise {

: 1} catch 抛出错误：Promise {

: "err"} catch 无返回： Promise {

: undefined}

then 返回实值：Promise {

: 1} then 抛出错误：Promise {

: "err"} then 无返回： Promise {

: undefined}

resolved状态下：then执行，catch不执行 rejected状态下: then不执行，catch执行

关键在于undefined下，其实也属于resolved状态，

所以会有这个特点 我们经常使用时并不会在then和catch中去返回特定的值， 于是我们假定callA和callB中返回的都是undefined: 我们的想要的结果是：resolve时只执行callA,reject时只执行callB

P_resolve.then(callA).catch(callB) callA执行后，callB不执行 符合 P_reject.then(callA).catch(callB) callA不执行后，callB执行 符合 而如果这样使用 P_reject.catch(callB).then(callA) 当callB执行时，callA也会被执行 不符合 P_resolve.catch(callB).then(callA) 当callB不执行，callA会被执行 符合

因此如果在复杂的链式调用中出现catch后会接上then的情况，catch中一定需要写上返回reject态的Promise，当你不需要执行后续的then时。

但同时也会导致，在后续没有另外一个catch的话，该catch抛出的错误被抛到应用顶层，最终系统报错。

基本也就能认为， 如果要安全地使用Promise，保证系统不报错的前提下，catch必须被最后调用并返回resolve状态。

ES6，ES7，Vue的基本认识和特点

Promise对象

1. 理解:

Promise对象: 代表了未来某个将要发生的事件(通常是一个异步操作)

有了promise对象, 可以将异步操作以同步的流程表达出来, 避免了层层嵌套的回调函数(俗称'回调地狱')

ES6的Promise是一个构造函数, 用来生成promise对象的实例

2. 使用promise基本步骤(2步):

? 创建promise对象

? 调用promise的then()

3. promise对象的3个状态

pending: 初始化状态

fullfilled: 成功状态

rejected: 失败状态

4. 应用:

使用promise实现超时处理

使用promise封装处理ajax请求

字符串扩展

includes(str) : 判断是否包含指定的字符串

startsWith(str) : 判断是否以指定字符串开头

endsWith(str) : 判断是否以指定字符串结尾

repeat(count) : 重复指定次数

ES7

1. 指数运算符(幂): **

2. Array.prototype.includes(value) : 判断数组中是否包含指定value

Vue 的基本认识

作者: 尤雨溪(一位华裔前 Google 工程师)

作用: 动态构建用户界面

Vue 的特点

1）遵循 MVVM 模式

2）编码简洁, 体积小, 运行效率高, 适合移动/PC 端开发

3）它本身只关注 UI, 可以轻松引入 vue 插件或其它第三方库开发项目

jQuery的Promise如何正确使用

关于jQuery的Promise的使用方法，大家了解多少？本文就主要和大家分享jQuery的Promise如何正确使用，希望能帮助到大家。先前了解了ES6的Promise对象，来看看jQuery中的Promise，也就是jQuery的Deferred对象。打开浏览器的控制台先。运行结果： 和ES6的Promise对象长的有点像，jQuery的Deferred对象也有resolve、reject、then方法，还有done、fail、always......方法。jQuery就是用这个Deferred对象来注册异步操作的回调函数，修改并传递异步操作的状态。玩玩Deferred：运行之后，Deferred对象的实例defer通过resolve方法把参数 “异步请求成功之后返回的数据” 传回到then方法中进行接收，，打印。和ES6的Promise相似，但是有一点点区别，再看下Promise：我们发现：1、创建Deferred对象的时候没有传参；而创建Promise对象的时候，传了参数（传了一个匿名函数，函数也有两个参数：resolve、reject）；2、Deferred对象直接调用了resolve方法；而Promise对象则是在内部调用的resolve方法；说明：Deferred对象本身就有resolve方法，而Promise对象是在构造器中通过执行resolve方法，给Promise对象赋上了执行结果的状态。这样就有一个弊端：因为Deferred对象自带resolve方法，拿到Deferred对象之后，就可以随时调用resolve方法，其状态可以进行手动干预了 这样的话就直接在外部直接给Deferred设置了状态，打印“在外部结束”，1s后打印“执行完成”，不会打印“异步请求成功之后返回的数据”了。显然，这不好。我发个异步请求，还没收到数据就让人在外部给我结束了。。。。当然这个坑jQuery肯定会填的，在Deferred对象上有一个promise方法，是一个受限的Deferred对象所谓受限的Deferred对象，就是没有resolve和reject方法的Deferred对象。这样就无法在外边改变Deferred对象的状态了。Deferred对象的then方法和done、fail语法糖我们知道，在ES6的Promise规范中，then方法接受两个参数，分别是执行完成和执行失败的回调，而jquery中进行了增强，还可以接受第三个参数，就是在pending状态时的回调，如下：deferred.then( doneFilter [, failFilter ] [, progressFilter ] )then方法：Deferred对象的then方法也是可以进行链式操作的。done，fail语法糖,分别用来指定执行完成和执行失败的回调,与这段代码是等价的：always的用法jquery的Deferred对象上还有一个always方法，不论执行完成还是执行失败，always都会执行，有点类似ajax中的complete。$.when的用法jquery中，还有一个$.when方法来实现Promise，与ES6中的all方法功能一样，并行执行异步操作，在所有的异步操作执行完后才执行回调函数。不过$.when并没有定义在$.Deferred中，看名字就知道，$.when，它是一个单独的方法。与ES6的all的参数稍有区别，它接受的并不是数组，而是多个Deferred对象，如下：jquery中没有像ES6中的race方法吗？就是以跑的快的为准的那个方法。对的，jquery中没有。

es5与es6的promise分别实现等待多个接口返回数据执行相应操作（4399笔试）

场景：有时候我们同时需要两个接口返回的数据才能实现进一步操作，下面介绍2种方法
方法1：利用js回调嵌套的方式

为了实现嵌套调用，另外定义一个函数，total，保证接口返回数据成功后执行打印百分比操作
实现如下：

方法2：利用es6的promise解决回调地狱问题
每个异步接口 返回一个promise对象

利用promisee.all方法保证接口数据成功返回再执行操作

Vue怎么进行ajax请求公共方法

这次给大家带来Vue怎么进行ajax请求公共方法，Vue进行ajax请求公共方法的注意事项有哪些，下面就是实战案例，一起来看一下。为了减少代码的冗余，小编给大家推荐一篇介绍了决定抽离出请求ajax的公共方法的文章，供大家参考。 我使用了ES6语法，编写了这个方法。/** * @param type 请求类型，分为POST/GET * @param url 请求url * @param contentType * @param headers * @param data * @returns {Promise

} */ ajaxData: function (type, url, contentType, headers, data) { return new Promise(function(resolve) { $.ajax({ type: type, url: url, data: data, timeout: 30000, //超时时间：10秒 headers: headers, success: function(data) { resolve(data); }, error: function(XMLHttpRequest, textStatus, errorThrown) { resolve(XMLHttpRequest); } }); }); } 通过回调函数的方式返回请求结果。 测试代码如下：getAjaxDataMethod: function () { const url = ""; const type = "POST"; const contentType = "application/json"; const headers = {}; const data = {}; Api.ajaxData(type, url, contentType, headers, data).then(function (res) { console.log(res); }).catch(function (err) { console.log(err); }) }测试通过！相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！推荐阅读：Angular17里的自定义指令使用详解JS里EventLoop的使用详解vue+cli单页面脚手架转换多页面脚手架的方法

ES6中的Promise.resolve到底有何作用

Deferred 和 Promise
ES6 和 jQuery 都有 Deffered 和 Promise，但是略有不同。不过它们的作用可以简单的用两句话来描述
Deffered 触发 resolve 或 reject
Promise 中申明 resolve 或 reject 后应该做什么（回调）
在 jQuery 中
var deferred = $.Deferred(); var promise = deferred.promise();
在 ES6 中
var deferred = Promise.defer(); var promise= defered.promise;
MDN 宣布 Deferred 在 Gecko 30 中被申明为过期，不应该再使用，而应该用 new Promise() 来代替。关于 new Promise() 将在后面说明。
jQuery 的 Deferred/Promise
jQuery 中最常用的 Promise 对象是 $.ajax() 返回的，最常用的方法不是 then ，而是 done 、 fail 和 always 。除了 $.ajax() 外，jQuery 也提供了 $.get() 、 $.post() 和 $.getJSON() 等简化 Ajax 调用，它们返回的和 $.ajax() 的返回值一样，是个 Promise 对象。
实际上 $.ajax() 返回的是一个 jqXHR 对象 。但 jqXHR 实现了 jQuery 的 Promise 接口，所以也是一个 Promise 对象。
done() 、 fail() 和 always()
done() 添加 deferred.resolve() 的回调， fail() 添加 deferred.reject() 的回调。所以在 Ajax 调用成功的情况下执行 done() 添加的回调，调用失败时执行 fail() 添加的回调。但不管成功与否，都会执行 always() 添加的回调。
这里 done() 、 fail() 和 always() 都是以类似事件的方式添加回调，也就意味着，不管执行多次次 done() 、 fail() 或 always() ，它们添加的若干回调都会在符合的条件下依次执行。
一般情况下会这样执行 Ajax
// 禁用按钮以避免重复提交 $("#theButton").prop({ disabled: true }); // 调用 Ajax 提交数据，假设返回的是 JSON 数据 var jqxhr = $.ajax("do/example", { type: "post", dataType: "json", data: getFormData() }); jqxhr.done(function(jsonObject) { // Ajax 调用成功 console.log("success with data", jsonObject); }).fail(function() { // Ajax 调用失败 console.log("failed") }).always(function() { // 不管成功与否，都会执行，取消按钮的禁用状态 $("#theButton").prop({ disabled: false }); });
上面是最普通最常用的用法，但是在一个项目中总是这么写 Ajax，有点累，稍微约定一下再封装一下就使用起来就会便捷得多。首先，假设我们定义返回的 JSON 是这样的格式：
{ "code": "int, 0 表示成功，其它值表示出错", "message": "string, 附加的消息，可选", "data": "object，附加的数据，可选 }
然后为项目公共类 app 定义一个 ajax 方法
app.ajax = function(button, url, data) { if (button) { button.prop("disabled", true); } return $.ajax(url, { type: "post", dataType: "json", data: data }).done(function(json) [ if (json.code !== 0) { showError(json.message || "操作发生错误"); } }).fail(function() { showError("服务器错误，请稍后再试"); }).always(function() { if (button) { button.prop("disabled", false); } }); }; // 调用 app.ajax("do/example", getFormData().done(function(json) { if (json.code === 0) { // 只需要处理正确的情况啦 } });
不过还是有点不爽，如果不需要判断 json.code === 0 就更好了。这个……可以自己用一个 Deferred 来处理：
app.ajax = function(button, url, data) { if (button) { button.prop("disabled", true); } var deferred = $.Deferred(); $.ajax(url, { type: "post", dataType: "json", data: data }).done(function(json) [ if (json.code !== 0) { showError(json.message || "操作发生错误"); deferred.reject(); } else { deferred.resolve(json); } }).fail(function() { showError("服务器错误，请稍后再试"); deferred.reject(); }).always(function() { if (button) { button.prop("disabled", false); } }); return deferred.promise(); }; // 调用 app.ajax("do/example", getFormData()).done(function(json) { // json.code === 0 总是成立 // 正常处理 json.data 就好 });
注意，这里已经不是直接返回 $.ajax() 的结果 jqXHR 对象了，返回的是新建 Deferred 对象的 promise 对象。
复习了 Ajax，现在需要切入正题，找到 jQuery Promise 和 ES6 Promise 接近的地方—— then() 。
jQuery deferred.then()
在 jQuery 1.8 以前（不含 1.8，比如 jQuery 1.7.2）， deferred.then() 就是一个把 done() 和 fail() 放在一起的语法糖。jQuery 在 1.8 版本的时候修改了 deferred.then() 的行为，使 then() 的行为与 Promise 的 then() 相似。从 jQuery 的文档可以看到 1.8 版本的变化——干掉了 callback，换成了 filter：
// version added: 1.5, removed: 1.8 deferred.then( doneCallbacks, failCallbacks ) // version added: 1.7, removed: 1.8 deferred.then( doneCallbacks, failCallbacks [, progressCallbacks ] ) // version added: 1.8 deferred.then( doneFilter [, failFilter ] [, progressFilter ] )
可以简单的把 callback 当作一个事件处理，值用于 callback 之后一般不会改变；而 filter 不同，一个值传入 filter 再从 filter 返回出来，可能已经变了。还是举个例子来说明
var deferred = $.Deferred(); var promise = deferred.promise(); promise.then(function(v) { console.log(`then with ${v}`); }).done(function(v) { console.log(`done with ${v}`); }); deferred.resolve("resolveData");
在 jQuery 1.7.2 中的结果
then with resolveData done with resolveData
在 jQuery 1.8.0 中的结果
then with resolveData done with undefined
从上面来看，jQuery 的 deferred.then() 语义和 ES6 Promise.then() 语义基本一致。如果把上面的 app.ajax 换成 then() 实现会有助于对 ES6 Promise 的理解。
app.ajax = function(button, url, data) { if (button) { button.prop("disabled", true); } return $.ajax(url, { type: "post", dataType: "json", data: data }).then(function(json) { if (json.code !== 0) { showError(json.message || "操作发生错误"); return $.Deferred().reject().promise(); } else { return $.Deferred().resolve(json).promise(); } }, function() { showError("服务器错误，请稍后再试"); deferred.reject(); }).always(function() { if (button) { button.prop("disabled", false); } }); }; // 调用方式没变，用 done，也可以用 then app.ajax("do/example", getFormData()).done(function(json) { // json.code === 0 总是成立 // 正常处理 json.data 就好 }); 从 jQuery Promise 到 ES6 Promise
上面的代码太长，提炼一下关键部分（示意，不能运行）
var promise = $.ajax(); promise.then(function(data) { // resolve return data.code ? new Promise().reject() : new Promise().resolve(data); // 如果没有错，就返回一个新的 promise，并使用 data 来 resolve， // 也可以直接返回 data， // 这样后面 then 的 resolve 部分才能收到数据 }, function() { // rejected }); // 调用阶段 promise.then(function(data) { // 处理 data });
也许你没注意到，其实上面的代码基本上就是 ES6 的 Promise 了。下面正式用 ES6 Promise 改写上面的示意代码
var promise = new Promise(function(resolve, reject) { $.ajax().then(resolve, reject); // 上面这句没看懂？那换成这样你一定会懂 // $.ajax().then(function(data) { // resolve(data); // }, function() { // reject(); // }); }).then(function(data) { return data.code ? Promise.reject() : Promise.resolve(data); // 这里 Promise.resolve(data) 同样可以直接替换为 data }); // 调用没变 promise.then(function(data) { // 处理 data });
怎么样，差别不大吧。不知不觉就会 ES6 Promise 了！
ES6 的 Promise
上面已经把 ES6 的 Promise 带出来了，现在只需要把常用方法列出来作为参考即可
注意，小写的 promise 表示 Promise 对象
new Promise(executor) ，产生一个新的 Promise 对象
> `executor(resolve, reject)` > `executor`、`resolve` 和 `reject` 均为函数，在 `executor` 中，正确处理调用 `resolve()` 返回数据，异常处理直接 `throw new Error()` 或调 `reject()` 返回数据。
Promise.resolve(data) ，产生 Promise 对象并 resolve
Promise.reject() ，产生 Promise 对象并 reject
promise.then(onResolve, onReject) ，然后……继续处理
promise.catch(onReject) ， project.then(null, onReject) 的语法糖，和 jQuery 的 promise.fail() 差不多（但不同）。

Promise和Observable的区别

refer: promise-vs-observable 先上总结：

A Promise handles a single event when an async operation completes or fails. Note: There are Promise libraries out there that support cancellation, but ES6 Promise doesn't so far.
An Observable is like a Stream and allows to pass zero or more events where the callback is called for each event. Observable 允许 0 or more event，回调函数在每次event的时候都会被执行。
Often Observable is preferred over Promise because it provides the features of Promise and more. With Observable it doesn't matter if you want to handle 0, 1, or multiple events. You can utilize the same API in each case. 通常来说，Observable比Promise更好，因为它提供了不止Promise的其他特性。
Observable also has the advantage over Promise to be cancelable . If the result of an HTTP request to a server or some other expensive async operation isn't needed anymore, the Subscription of an Observable allows to cancel the subscription, while a Promise will eventually call the success or failed callback even when you don't need the notification or the result it provides anymore. Observable有一个优势：可取消。如果不再需要一个HTTP请求/某些昂贵的异步操作，Observable可以取消订阅，而Promise仍会执行 success/failed 回调函数。
Observable provides operators like map , forEach , reduce , ... similar to an array. There are also powerful operators like retry() , or replay() , ... that are often quite handy. A Promise handles a single event when an async operation completes or fails. 此外，Observable还提供了很多类数组的操作子，以及更多的高阶操作子。
Both Promises and Observables will help us work with the asynchronous functionalities in JavaScript. They are very similar in many cases, however, there are still some differences between the two as well, promises are values that will resolve in asynchronous ways like http calls. On the other hand, observables deal with sequence of asynchronous events. The main differences are listed as below:
promise:
observable:
Also, I've created the graphical image for you below to show the differences visually: