实现一个promise 以及promise的其他用法

Promise.all Promise.race 一个Promise实现

基本用法

var p = new Promise(function(resolve){
    setTimeout(function(){
        resolve(111);
    },1000)
});
p.then(function(value){
    console.log("承诺解决了,拿到的数据为："+value);
});
p.catch(function(error){
    console.log("rejected callback");
})

1. Promise.all()的用法
   Promise.all可以将多个Promise实例包装成一个新的Promise实例。同时，成功和失败的返回值是不同的，成功的时候返回的是一个结果数组，而失败的时候则返回最先被reject失败状态的值

   var p1 = new Promise(function(resolve){
           resolve("p1 resolved");
   });
   var p2 = new Promise(function(resolve){
           resolve('p2 resolved');
   });
   var p3 = new Promise(function(resolve){
           resolve("p3 resolved");
   });
   var p = Promise.all([p1,p2,p3]);//这里得到了一个新的promise
   p.then(function(value){
       console.log("p resolved, 得到的参数为："+value);
   })
   .catch(function(error){
       console.log("p rejected,"+error);
   });
   //output：p resolved, 得到的参数为：p1 resolved,p2 resolved,p3 resolved

2. Promise.race()的用法
   顾名思义，Promse.race就是赛跑的意思，意思就是说，Promise.race([p1, p2, p3])里面哪个结果获得的快，就返回那个结果，不管结果本身是成功状态还是失败状态

   let p1 = new Promise((resolve, reject) => {
     setTimeout(() => {
       resolve('success')
     },1000)
   })
   
   let p2 = new Promise((resolve, reject) => {
     setTimeout(() => {
       reject('failed')
     }, 500)
   })
   
   Promise.race([p1, p2]).then((result) => {
     console.log(result)
   }).catch((error) => {
     console.log(error)  // 打开的是 'failed'
   })

实现一个promise

function Promise(fn) {
    var state = 'pending',
        value = null,
        deferreds = [];

    this.then = function (onFulfilled, onRejected) {
        return new Promise(function (resolve, reject) {
            handle({
                onFulfilled: onFulfilled || null,
                onRejected: onRejected || null,
                resolve: resolve,
                reject: reject
            });
        });
    };

    function handle(deferred) {
        if (state === 'pending') {
            deferreds.push(deferred);
            return;
        }
        var cb = state === 'fulfilled' ? deferred.onFulfilled : deferred.onRejected,
            ret;
        if (cb === null) {
            cb = state === 'fulfilled' ? deferred.resolve : deferred.reject;
            cb(value);
            return;
        }
        try {
            ret = cb(value);
            deferred.resolve(ret);
        } catch (e) {
            deferred.reject(e);
        } 
    }

    function resolve(newValue) {
        if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
            var then = newValue.then;
            if (typeof then === 'function') {
                then.call(newValue, resolve, reject);
                return;
            }
        }
        state = 'fulfilled';
        value = newValue;
        finale();
    }

    function reject(reason) {
        state = 'rejected';
        value = reason;
        finale();
    }

    function finale() {
        setTimeout(function () {
            deferreds.forEach(function (deferred) {
                handle(deferred);
            });
        }, 0);
    }

    fn(resolve, reject);
}

赏

1分也是爱

微信