ES6-Promise

我们知道的，在 JavaScript 中，所有代码都是单线程的，也就是同步执行的。而 Promise 就为异步编程提供了一种解决方案。

1 基本概念

  • 名称：
    译为“承诺”，这也就表达了将来会执行的操作，代表异步操作；
  • 状态：
    一共有三种状态，分别为pending（进行中）、fulfilled（已成功）和rejected（已失败）。
  • 特点：
    (1)只有异步操作可以决定当前处于的状态，并且任何其他操作无法改变这个状态；
    (2)一旦状态改变，就不会在变。状态改变的过程只可能是：从pending变为fulfilled和从pending变为rejected。如果状态发生上述变化后，此时状态就不会在改变了，这时就称为resolved（已定型）

2 基本用法

Promise 对象是由关键字 new 及其构造函数来创建的。
首先，
介绍一下如何创建一个 Promise；

const promise = new Promise((resolve, reject) => {
    // do something here ...
    if (success) {
        resolve(value); // fulfilled
    } else {
        reject(error); // rejected
    }
});

由上述代码我们可知：
该构造函数接收两个函数作为参数，分别是resolve和reject。
当异步操作执行成功后，会将异步操作结果作为参数传入resolve函数并执行，此时 Promise对象状态从pending变为fulfilled；
失败则会将异步操作的错误作为参数传入reject函数并执行，此时 Promise对象状态从pending变为rejected；

接下来，
我们通过then方法，分别指定resolved状态和rejected状态的回调函数。

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

then方法可以接收两个回调函数作为参数，第一个回调函数就是fulfilled状态时调用；第二个回调函数就是rejected时调用。这边的第二个参数是可选的，不一定要提供。

3 方法

(1) Promise.all(iterable)

  • 参数
    iterable 必须是一个可迭代对象，如 Array 或 String。
  • 返回值
    一个新的Promise实例。

Promise.all 的使用
如果传入的参数中存在不是Promise实例，则会先调用Promise.resolve，将其转为Promise实例，再进一步处理。

var p1 = Promise.resolve(3);
var p2 = 1337;
var p3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
}); 

Promise.all([p1, p2, p3]).then(values => { 
  console.log(values); 
});

//  [3, 1337, "foo"]

Promise.all 的异步和同步
如果传入的参数为空的可迭代对象，则同步返回一个已完成（already resolved）状态的 Promise；
非空时则返回一个异步完成（asynchronously resolved） Promise

var iterable = [Promise.resolve(1), Promise.resolve(2)];

var p = Promise.all(iterable);

console.log(p);

setTimeout(function(){
    console.log(p);
});

// Promise {<pending>}
// Promise {<resolved>: Array(2)}

Promise.all 的快速返回失败行为
传入的参数中任意一个promise返回失败时，那么整体立即返回失败，返回的错误信息是第一个失败的promise结果。

var p1 = new Promise((resolve, reject) => { 
  setTimeout(resolve, 1000, 'one'); 
}); 
var p2 = new Promise((resolve, reject) => { 
  setTimeout(resolve, 2000, 'two'); 
});
var p3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 3000, 'three');
});
var p4 = new Promise((resolve, reject) => {
  reject('p4 reject!');
});
var p5 = new Promise((resolve, reject) => {
  reject('p5 reject!');
});

Promise.all([p1, p2, p3, p4, p5]).then(values => { 
  console.log(values);
}, reason => {
  console.log(reason)
});

// p4 reject!

.
.
.
.
.
.

(2) Promise. race(iterable)

  • 参数
    iterable 必须是一个可迭代对象，如 Array 或 String。
  • 返回值
    一个新的Promise实例。

Promise.race 的使用
race有赛跑之译，因此返回的新实例状态，是跟随参数中最先改变状态的那个实例；如果不是Promise实例，依旧先用Promise.resolve方法，转化后再进一步处理。
如果传的迭代为空，则返回的 Promise 永远等待

var promise1 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 500, 'one-resolve-500');
});

var promise2 = new Promise(function(resolve, reject) {
    setTimeout(reject, 400, 'two-reject-400');
});

Promise.race([promise1, promise2]).then(function(value) {
    console.log(value);
}, function(err) {
    console.log(err);
});

// two-reject-400

.
.
.
.
.
.

(3) Promise.resolve(value)

返回一个以给定的值解析后的Promise对象；
参数 value 主要有以下几种情况：

  • 一个Promise实例
    原封不动的返回该实例；

    var original = Promise.resolve('我在第二行');
var cast = Promise.resolve(original);
cast.then(function(value) {
  console.log('value: ' + value);
});
console.log('original === cast ? ' + (original === cast));

// "original === cast ? true"
// "value: 我在第二行"

  • 一个thenable对象：是指含有then方法的对象
    跟随这个thenable对象的，采用它的最终状态；

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

let p = Promise.resolve(thenable);

p.then(function(value) {
  console.log(value);
})

 // 42

  • 普通数据：[String|Array|Object|Number]
    直接将传入参数当最终结果并返回一个新的Promise；

    let p = Promsie.resolve(123);
p.then(function(num) {
  console.log(num);
})

// 123

  • 无参数
    直接返回一个resolved状态的Promise对象

    let p = Promsie.resovle();
p.then(function() {
  // do something here...
})

.
.
.
.
.
.

(4) Promise.reject(reason)

  • 参数：表示被拒绝的原因；

⚠️传入的参数会原封不动的作为 reject 函数的理由，并不会因为传入的参数 Promise 或者是 thenable 对象而有所不同

  • 返回值：一个含有reason的状态为rejected的Promise

.
.
.
.
.
.

4 Promise原型

(1) Promise.prototype.then()

Promise 的实例具有 then 方法，主要作用是为 Promise 实例发生状态改变时添加回调函数。
它接收两个回调函数作为参数，第一个参数是 fulfilled状态时的回调函数；第二个参数是rejected状态时的回调函数，可不传入。
并且该方法返回一个新的Promise对象。

  • 语法： 
    p.then(onResolve, onReject);

p.then(function(value) {
   // fulfillment
  }, function(reason) {
  // rejection
});

.
.
.
.

(2) Promise.prototype. catch()

返回一个Promise，并且处理拒绝的情况。它的行为与调用Promise.prototype.then(undefined, onRejected)相同。

  • 语法 
    p.catch(onReject)

 p.catch(function(reason) {
     // 拒绝
 });
  • 推荐使用catch方法，不要在then方法中定义rejected状态的回调函数；这是因为使用catch还可以捕获在then方法执行中存在的错误。 
      // bad
promise
  .then(function(data) {
    // success
  }, function(err) {
    // error
  });

// good
promise
  .then(function(data) { 
    // success
  })
  .catch(function(err) {
    // error
  });

.
.
.
.
.
.

(3) Promise.prototype. finally()

返回一个Promsie。是指，在上一轮 promise 运行结束后，无论fulfilled还是 rejected，都会执行指定的回调函数。
该方法适合，无论结果如何都要进行的操作，例如清除数据。

  • 语法：该回调函数的不接受任何参数； 
      p.finally(onFinally);

  p.finally(function() {
   
  })
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Promise 对象
    Promise 对象 Promise 的含义 Promise 是异步编程的一种解决方案，比传统的解决方案——回调函...
    neromous阅读 8,727评论 1赞 56
  • 异步回调 2 - ES6 Promise
    如果浏览已经有了Promise对象，那么页就说明浏览器的js引擎里已经有了Promsise队列，这样就可以利用Pr...
    羊烊羴阅读 518评论 0赞 0
  • ES6-Promise 对象
    1.Promise 的含义 Promise是异步编程的一种解决方案，比传统的解决方案- -回调函数和事件- - 更...
    海之深处爱之港湾阅读 552评论 0赞 2
  • ES6 promise
    Promise是一个构造函数，自己身上有all、reject、resolve这几个眼熟的方法，原型上有then、c...
    泡泡糖_966c阅读 339评论 0赞 0
  • Promise 对象
    一、Promise的含义 Promise在JavaScript语言中早有实现，ES6将其写进了语言标准，统一了用法...
    Alex灌汤猫阅读 837评论 0赞 2