ES6新特性之Promise

时间 2019-11-26

原文原文链接

基本概念

从字面意思上来看，Promise是承诺。它表示一个异步操做的最终状态（完成或失败），以及该异步操做的结果值。根据Pormise的执行结果能够拿到一个最终状态。数组

new Promise（{
        function(resolve,reject){
            /* executor */
        }
    }）;

通常来说，有三种状态：promise

pending，进行中
fulfilled，已成功
rejected，已失败

关于三种状态，实际上分为两种状况：一种是从pending到fulfilled，也就是执行而后成功；另外一种pending到rejected是执行，而后失败。Promise 的状态一旦肯定就再也不改变。只可以从pending到fulfill或者是从pending到rejected，肯定以后的状态称之为resolved。resolved以后添加回调会当即执行获得结果，resolved通常指的是fulfilled状态。异步

一旦新建会当即执行，没法中途取消。Promise构造函数执行时当即调用executor函数。函数

基本用法

Promise接收一个函数做为参数，该函数的参数分别是resolved和rejectfetch

let promise = new Promise(function(resolve,reject){
        console.log('new promise');
        setTimeout(function(){
            console.log('promise resolved');
            return resolved('success');
        },1000);
    });

Promise实例生成后在then方法中指定resolved状态和rejected（可选）状态的回调函数url
```
promise.then(function(value){
        console.log('resolved callback',value);
    });
```

Promise传递prototype

const promise1 = new Promise(function (resolve,reject)){
        /* .... */
    }

属性和方法

Promise.prototype.then，是Promise状态改变时的回调函数，也就是定义了一个承诺，那么获得的结果是什么。它返回一个新的Promise，新的Promise意味着能够链式调用，也就是.then以后还能够.then 。code

// 顺次调用
    let promise1 = new Promise(function(resolve, reject) {
        console.log('new promise1');

        setTimeout(function() {
            console.log('promise1 resolved');
            return resolve("promise1 success");
        }, 2000);
    });

    let promise2 = new Promise(function(resolve, reject) {
        console.log('new promise2');

        setTimeout(function() {
            console.log('promise2 resolved');
            return resolve("promise2 success");
        }, 4000);
    });

    promise1
      .then(function(value) {
        console.log('then1 callback', value);
        return value;
      })
      .then(function(value) {
        console.log('then2 callback', value);
        return promise2;
      })
      .then(function(value) {
        console.log('then3 callback', value);
        return '';
      })

Promise.prototype.catch(错误捕获)
错误发生时的回调函数，至关于.then（null/undefined，reject）的一个别名，它捕获reject以及then回调运行时的错误。orm

// 顺次调用
    let promise = new Promise(function(resolve, reject) {
      throw new Error('Error');
    });
    promise.catch(function(error) {
      console.log(error);
    });

    // Error: Error

Promise.prototype.finally（最后）
无论成功或失败，这个方法不管状态如何都会执行。它不接受任何参数，与状态无关，不依赖Promise执行结果。对象

Promise.all（全部）
把全部的Promise放在一块儿，而后当全部的Promise所有resolved，这个Promise.all才会真正的resolved。也就是全部的成功了它才成功，能够理解成一个包装器，它包装多个Promise为一个新的Promise，那么Promise.all实际上接收的是一个数组，fulfilled条件是全部包装的Promise所有fulfilled。

const promise1 = new Promise((resolve, reject) => {
      resolve({
        code: 200,
        data: [],
      });
    })
      .then(result => result)
      .catch(err => ({
        code: 200,
        data: [],
      }));

       const promise2 = new Promise((resolve, reject) => {
        throw new Error('Error');
      })
        .then(result => result)
        .catch(err => ({
          code: 200,
          data: [],
        }));

      Promise.all([promise1, promise2])
        .then(result => console.log(result))
        .catch(e => console.log(e));
      ```  
    使用Promise.all，咱们须要给每个Promise都加一个catch，返回一个备用的结果，这个月整个的Promise.all才会获得一个resolved结果。

Promise.race（谁先返回就先执行谁）

包含多个Promise为一个新的Promise，返回第一个fulfilled。
    const promise = Promise.race([
        fetch('/url'),
        new Promise(function (resolve, reject) {
          setTimeout(() => {
            return reject(new Error('request timeout'));
          }, 5000);
        })
      ]);

      p
        .then(console.log)
        .catch(console.error);

Promise.resolve（状态）
将现有对象转为Promise对象，状态为fulfilled。
```
const promise = Promise.resolve('hello');
    promise.then(res => alert(res));
```

Promise.reject
将现有对象转为Promise对象，状态为rejected。

const promise = Promise.reject('word');
    promise.then(res => alert(res)).catch(err => alert(err));