ES6 Promise对象

Promise  ,简单说就是一个容器,里面保存着某个未来才会结束的事件(通常是一个异步操作)的结果。

Promise 对象有以下两个特点。

(1)对象的状态不受外界影响。 Promise 对象代表一个异步操作,有三种状态: Pending (进行中)、 Resolved (已完
成,又称 Fulfilled )和 Rejected (已失败)。只有异步操作的结果,可以决定当前是哪一种状态,任何其他操作都无法改变这
个状态。

(2)一旦状态改变,就不会再变,任何时候都可以得到这个结果。 Promise 对象的状态改变,只有两种可能:
从 Pending 变为 Resolved 和从 Pending 变为 Rejected 。

局限:

无法取消 Promise ,一旦新建它就会立即执行,无法中途取消。其次,如果不设置回调函
数, Promise 内部抛出的错误,不会反应到外部。第三,当处于 Pending 状态时,无法得知目前进展到哪一个阶段(刚刚
开始还是即将完成)。

使用方法:

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

var promise = new Promise(function(resolve, reject) {
// ... some code
if (/*  异步操作成功 */){
resolve(value);
} else {
reject(error);
}
});
// resolve  函数的作用是,将 Promise 对象的状态从 “ 未完成 ” 变为 “ 成功 ” (即从 Pending 变为 Resolved ),在异步操作成功时调
   用,并将异步操作的结果,作为参数传递出去
// reject  函数的作用是,将 Promise 对象的状态从 “ 未完成 ” 变为 “ 失败 ” (即从
   Pending 变为 Rejected ),在异步操作失败时调用,并将异步操作报出的错误,作为参数传递出去。

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

promise.then(function(value) {
// success
}, function(error) {
// failure
});

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

Promise也可以用另外一个Promise对象的状态作为参数。

    var p1 = new Promise(function (resolve, reject) {
        setTimeout(() => resolve(‘success‘), 3000)
    })
    var p2 = new Promise(function (resolve, reject) {
        setTimeout(() => resolve(p1), 1000)
    })
    p2.then(function(value){
        console.log(value)
    },function(error){
            console.log(error)
    });    //  三秒后P1的状态由Pengding变为Resolved,P2执行Resolved方法

then 方法返回的是一个新的 Promise 实例(注意,不是原来那个 Promise 实例)。因此可以采用链式写法,即 then 方法后面
再调用另一个 then 方法。

getJSON("/posts.json").then(function(json) {
return json.post;
}).then(function(post) {
// ...
});// 依次指定了两个回调函数。第一个回调函数完成以后,会将返回结果作为参数,传入第二个回调函数
前一个回调函数,有可能返回的还是一个 Promise 对象(即有异步操作),这时后一个回调函数,就会等待该 Promise 对象的状态发生变化,才会被调用。
getJSON("/post/1.json").then(function(post) {
return getJSON(post.commentURL);
}).then(function funcA(comments) {
console.log("Resolved: ", comments);
}, function funcB(err){
console.log("Rejected: ", err);
});
// 运用箭头函数可以简写为

getJSON("/post/1.json").then(function(post){
  return getJSON(post.commentURL)
)}.then(
     comments => console.log("Resolved: ", comments),
     err => console.log("Rejected: ", err)
});
getJSON 方法返回一个 Promise 对象,如果该对象状态变为 Resolved ,则会调用 then 方法指定的回调函数;如果异步操作抛出错误,状态就会变为 Rejected ,就会调用 catch 方法指定的回调函数,处理这个错误。另外, then 方法指定的回调函数,如果运行中抛出错误,也会被 catch 方法捕获。
p.then((val) => console.log("fulfilled:", val))
.catch((err) => console.log("rejected:", err));
//  等同于
p.then((val) => console.log(fulfilled:", val))
.then(null, (err) => console.log("rejected:", err));

一般来说,不要在 then  方法里面定义 Reject 状态的回调函数(即 then  的第二个参数),总是使用 catch  方法。

Promise.all()

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

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

p 的状态由 p1 、 p2 、 p3 决定,分成两种情况。
(1)只有 p1 、 p2 、 p3 的状态都变成 fulfilled , p 的状态才会变成 fulfilled ,此时 p1 、 p2 、 p3 的返
回值组成一个数组,传递给 p 的回调函数。
(2)只要 p1 、 p2 、 p3 之中有一个被 rejected , p 的状态就变成 rejected ,此时第一个被 reject 的实例的返
回值,会传递给 p 的回调函数。

Promise.race()

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

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

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

Promise.resolve()
有时需要将现有对象转为 Promise 对象

Promise.resolve(‘foo‘)
//  等价于
new Promise(resolve => resolve(‘foo‘))

Promise.reject()
Promise.reject(reason) 方法也会返回一个新的 Promise 实例,该实例的状态为 rejected

var p = Promise.reject(‘ 出错了 ‘);
//  等同于
var p = new Promise((resolve, reject) => reject(‘ 出错了 ‘))
时间: 2024-10-23 08:50:00

ES6 Promise对象的相关文章

ES6 Promise 对象

es6 Promise 对象是异步编程的一种解决方案.(在javascript世界里,是单线程顺序执行的)从语法上说,Promise 是一个对象,从它可以获取异步操作的消息. Promise 异步操作有三种状态:pending(进行中).fulfilled(已成功)和 rejected(已失败).除了异步操作的结果,任何其他操作都无法改变这个状态.Promise 对象只有:从 pending 变为 fulfilled 和从 pending 变为 rejected 的状态改变.只要处于 fulfi

ES6 Promise对象(七)

一.Promise介绍1.Promise简单说就是一个容器,里面保存着某个未来才会结束的事件(通常是一个异步操作)的结果2.Promise可以将异步操作以同步操作的流程表达出来,避免了层层嵌套的回调函数.此外,Promise对象提供统一的接口,使得控制异步操作更加容易 二.基本用法[使用时注意环境及异步操作相关包安装]在node环境中使用ajax时需要安装jsdom.jqury包配置常量: //创建window环境 const {JSDOM} = require('jsdom'); const

Promise 对象

es6 Promise 对象 定义参考 案例源码 戳这里 ps:每个案例都是基于上一个改造的 一.Promise 简介 Promise 是一个对象,从它可以获取异步操作的消息 案例1 新建项目 [demo] |-- src |-- index.html |-- index.js |-- webpack.config.js |-- package.json demo/package.json { "name": "webpack", "version&quo

ES6深入学习记录(二)promise对象相关

1.Promise的含义 Promise是异步编程的一种解决方案,比传统的解决方案--回调函数和事件更合理和强大.ES6将其写进了语言标准,统一了用法,原生提供了promise对象. 所谓Promise,简单说就是一个容器,里面保存着某个未来才会结束的事件(通常是一个异步的操作)的结果.从语法上说,Pormise是一个对象,从它可以获取异步操作的消息.Promise提供统一的API.各种异步操作都可以用同样的方法进行处理. Promise对象的两个特点: 1.对象的状态不受外界影响.Promis

ES6 - promise对象

Promise的设计初衷 我们使用ajax请求数据,得到数据后再对数据进行操作,可是有时候,对得到的数据进行操作的过程中,可能又要用到ajax请求,这时,我们的代码就变成了这样: $.ajax({ success:function(res1){ //...请求B开始,B依赖A返回的数据 $.ajax({ sucess:function(res2){ //...请求C开始,C依赖B返回的数据 $.ajax({ sucess:function(res3){ } }); } }); } }); 这种写

ES6的promise对象应该这样用

ES6修补了一位Js修真者诸多的遗憾. 曾几何时,我这个小白从js非阻塞特性的坑中爬出来,当我经历了一些回调丑陋的写法和优化的尝试之后,我深深觉得js对于多线程阻塞式的开发语言而言,可能有着其太明显的缺点,而又无法忽略的是也正因为这一点,node.js处理并行的能力被人看作优点,在我看来,这其实有着些讽刺的意味,就好像踢足球时有的人总夸你腿短,所以频率快下盘稳好控球...好在js从出生以来就有一种独特的特质,就是模仿,对,就是模仿,模仿别人的优点来补足自己,同时保持自己的长处. ES6就是通过P

es6中的promise对象

Promise是异步里面的一种解决方案,解决了回调嵌套的问题,es6将其进行了语言标准,同意了用法,提供了`promise`对象, promise对象有三种状态:pending(进行中) .Resolved(已经完成)和Rejected(已失败) ES6规定,Promise对象是一个构造函数,用来生成Promise实例. var promise=new Promise(function(resove,reject){ if (/* 异步操作成功 */){ resolve(value); } el

ES6学习笔记--promise对象

Promise是异步编程的一种解决方案,比传统的解决方案--回调函数和事件更合理和更强大.它由社区最早提出和实现,ES6将其写进了语言标准,统一了用法,原生提供了Promise对象. Promise对象有以下两个特点. (1)对象的状态不受外界影响.Promise对象代表一个异步操作,有三种状态:Pending(进行中).Resolved(已完成,又称 Fulfilled)和Rejected(已失败).只有异步操作的结果,可以决定当前是哪一种状态,任何其他操作都无法改变这个状态.这也是Promi

es6 之 promise 对象

异步编程 传统方案:事件 + 回调函数 ES6 的新方案:Promise 对象 Promise 异步操作有 3 种状态 pending: 进行中 resolved: 已完成 rejected: 已失败 Promise 异步操作的状态变化仅限下面两种方式 pending –> resolved pending –> rejected 创建一个 Promise 实例: promise 构造函数接收一个函数作为参数,并且这个函数有两个参数,这两个参数是也是两个函数,不过这两个函数由 JavaScri