ES6总结之Promise

Promise

1. Promise介绍

Promise是异步编程的一种解决方案，用来替代传统的回调方案。

所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。通过Promise实例调用then()方法表示异步语句执行后要做的事情。

Promise是一个构造函数，自身有race、all、reject和resolve方法。原型上有：then和catch方法

var p = new Promise(function (resolve,reject) {
  if(// 异步操作成功) {
    resolve(data)
  }
  reject(err)
});
p.then(function(data) {
  // success
}, function(err) {
  // failure
})

1、Promise构造方法接受带有两个参数resolve和reject的匿名函数作为参数

2、resolve将Promise的状态置为成功，并将异步操作结果data作为参数传给成功回调函数

3、reject将Promise的状态置为失败，并将异步操作错误err作为参数传给失败回调函数

4、then方法绑定两个回调函数，分别用来处理Promise成功状态和失败状态

5、生成新的promise实例时，就会立即执行其中的异步操作

2. Promise状态

Promise对象代表一个异步操作，有三种状态:Pending Resolved或者Fulfilled Rejected

1、只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态

2、一旦状态改变，就不会再变。且状态只能从Pending->Resolved或者Pending->Rejected

3. Promise.all()

Promise.all()接收一个由多个Promise实例组成的数组，如果数组中存在不是Promise的实例则会调用Promise.resolve()方法转换

var fs = require('fs');
function getString(url) {
    return new Promise(function(resolve,reject) {
        fs.readFile(url,function(err,data) {
            if(err) {
                reject(err)
                return
            }
            resolve(data.toString())
        })
    })
}
var arr = [1,2,3];
var promises = arr.map(function(item) {
    return getString('./text' + item + '.txt')
})
Promise.all(promises).then(function(posts) {
    console.log(posts)
})

当数组中所有Promise实例都进入Fullfiled状态，Promise.all实例才会进入Fullfiled状态
当数组中某个Promise实例进入Rejected状态，Promise.all实例进入Rejected状态

4. Promise.race()

跟Promise.all方法差不多。唯一的区别在于该方法返回的Promise实例并不会等待所有Proimse都跑完，而是只要有一个Promise实例改变状态，它就跟着改变状态。并使用第一个改变状态实例的返回值作为返回值

5. resolve()函数参数类型为Promise时

var d = new Date();
// 创建一个promise实例，该实例在2秒后进入fulfilled状态
var promise1 = new Promise(function(resolve, reject) {
  setTimeout(resolve, 2000, 'resolve from promise 1');
});
// 创建一个promise实例，该实例在1秒后进入fulfilled状态
var promise2 = new Promise(function(resolve, reject) {
  setTimeout(resolve, 1000, promise1); // resolve(promise1)
});
promise2.then(
  result => console.log('result:', result,new Date()-d),
  error => console.log('error:', error)
)

promise2中调用了resolve(promise1),promise2的状态由promise1决定

6. then()返回一个promise实例:

var d = new Date();
var promise1 = new Promise(function(resolve, reject) {
  setTimeout(resolve, 1000, 'resolve from promise1');
});
var promise2 = promise1.then(function(result) {
  console.log('promise1.then(resolve):', result);
});
// promise2 Promise对

1、当x为值的时候，promise2直接进入fulfilled状态，无论promise1的状态是fulfilled或者是rejected 2、当x为promise实例的时候，x的状态决定了promise2的状态

总结：在回调方法中一定要有return语句

7. Promise状态透传

如果当前的promise实例没有绑定回调或绑定的不是函数，那么实例就会把其状态以及不可变值或者不可变原因传递给当前实例调用.then方法返回的新promise实例

总结: 1. 回调中一定要使用return；防止丢失状态和结果 2. 在promise实例的最后使用catch做整体的错误捕获和处理 3. 利用Promise.then方法对回调函数返回结果的封装

var tic = function(timmer, str){
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            console.log(str);
            resolve(1);
        }, timmer);
    });
};
 

function *gen(){
    yield tic(3000, 'red');
    yield tic(1000, 'green');
    yield tic(2000, 'yellow');
}
 
var iterator = gen();
var step = function(gen, iterator){
    var s = iterator.next();
    if (s.done) {
        step(gen, gen());
    } else {
        s.value.then(function() {
            step(gen, iterator);
        });
    }
}
 
step(gen, iterator);

Contents