资讯专栏INFORMATION COLUMN

Promise理解与实现

hlcc / 2850人阅读

摘要:对象设置初始状态默认为等待状态用数组来保存成功函数设置为成功状态设置为失败状态调用回调函数增加方法根据状态执行成功失败方法执行成功方法执行失败方法将成功失败方法保存在数组里

promise理解

promise的意思是承诺。承诺理解为某个时候一些条件满足后,会兑现一件事情。

//为了方便理解我编一个小故事
//先假装我有一个女朋友
//她承诺如果她爸妈不回来就给我就可以去帮她修电脑 否则...
let promise = new Promise(function (success,fail) {
    //她说三秒后会告诉我今晚爸妈回不回来
    let herParentBack = Math.random() > 0.5 ? true : false;
    setTimeout(function(){
        if(herParentBack){
            success("我马上过来来帮你修你电脑");
        }else{
            fail("你要早点休息");
        }
    },3000);

});
 
 //第一个函数接收sucess函数传来的成功信息
 //第二个函数接收fail函数传来的失败信息

promise.then(function (sucessMsg) {
    console.log(sucessMsg);
},function (fail) {
    console.log(failMsg);
})
//我马上过来帮你修电脑

new Promise会传入一个回调函数,会伴着对象创建被立即调用。
这个function是承诺的主体内容。一般我们会做一些判断或者异步请求。(在这里要等女友回消息,我想好怎么回答她。)

promise.then方法在promise执行了success或fail后会执行对应的成功失败方法。 (这里理解为吧想好告诉她)

promise实现

根据promis规范promise Promise/A

Promise设置了三个状态,"pending"、"resolved"、"rejected"。

//Promise对象设置初始状态
function Promise(callback) {
    var self = this;
    //默认为等待状态
    self.status = "pending";
    self.value = undefined;
    self.reason = undefined;
    //用数组来保存成功函数
    self.onResolvedCallBacks = [];
    self.onRejectedCallbacks = [];

    function resolve(value){
        if(self.status === "pending"){
            //设置为成功状态
            self.status = "resolved";
            self.value = value;
            self.onResolvedCallBacks.forEach(item=>item(self.value));
        }
    }
    function reject(reason) {
        if(self.status === "pending"){
            //设置为失败状态
            self.status = "rejected";
            self.reason = reason;
            self.onRejectedCallbacks.forEach(item=>item(self.reason));
        }
    }

    callback(resolve,reject);
    //调用Promise回调函数
}

module.exports = Promise;

增加Promise.then方法

//根据Promise状态执行成功失败方法
Promise.prototype.then = function (onFulfilled,onRejected) {
    let self = this;
    onFulfilled = typeof onFulfilled == "function"?onFulfilled:function(value){return value};
  onReject = typeof onReject=="function"?onReject:function(reason){throw reason;}
    if(self.status === "resolved"){
        return new Promise(function (resolve,reject) {
            try {
                let x = onFullFilled(self.value);
                if(x instanceof Promise){
                    x.then(resolve,reject);
                }else{
                    resolve(x);
                }
            }
            catch(e) {
                reject(e);
            }
        })
        //执行成功方法
    }else if(self.status == "rejected"){
        return new Promise(function (resolve,reject) {
            try {
                let x = onRejected(self.reason);
                if(x instanceof Promise){
                    x.then(resolve,reject);
                }else{
                    resolve(x);
                }
            }
            catch(e) {
                reject(e)
            }
        })
        //执行失败方法
    }
    if(self.status === "pending"){
        return new Promise(function (reslove,reject) {
            self.onResolvedCallBacks.push(function () {
                let x = onFullFilled(self.value);
                if(x instanceof Promise){
                    x.then(resolve,reject);
                }else{
                    resolve(x);
                }
            })
            self.onRejectedCallbacks.push(function () {
                let x = onRejected(self.reason);
                if(x instanceof Promise){
                    x.then(resolve,reject);
                }else{
                    resolve(x);
                }
            })
        })
        //将成功失败方法保存在数组里
    }
}

Promise.all

Promise.all = all;
function all(iterable) {
  var self = this;
  if (!isArray(iterable)) {
    return this.reject(new TypeError("must be an array"));
  }

  var len = iterable.length;
  var called = false;
  if (!len) {
    return this.resolve([]);
  }

  var values = new Array(len);
  var resolved = 0;
  var i = -1;
  var promise = new this(INTERNAL);

  while (++i < len) {
    allResolver(iterable[i], i);
  }
  return promise;
  function allResolver(value, i) {
    self.resolve(value).then(resolveFromAll, function (error) {
      if (!called) {
        called = true;
        doReject(promise, error);
      }
    });
    function resolveFromAll(outValue) {
      values[i] = outValue;
      if (++resolved === len && !called) {
        called = true;
        doResolve(promise, values);
      }
    }
  }
}

Promise.race

Promise.race = function(iterable) {
  var self = this;
  if (!isArray(iterable)) {
    return this.reject(new TypeError("must be an array"));
  }

  var len = iterable.length;
  var called = false;
  if (!len) {
    return this.resolve([]);
  }

  var i = -1;
  var promise = new this(INTERNAL);

  while (++i < len) {
    resolver(iterable[i]);
  }
  return promise;
  function resolver(value) {
    self.resolve(value).then(function (response) {
      if (!called) {
        called = true;
        doResolve(promise, response);
      }
    }, function (error) {
      if (!called) {
        called = true;
        doReject(promise, error);
      }
    });
  }
}

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/92448.html

相关文章

  • JavaScript 异步

    摘要:从最开始的到封装后的都在试图解决异步编程过程中的问题。为了让编程更美好,我们就需要引入来降低异步编程的复杂性。写一个符合规范并可配合使用的写一个符合规范并可配合使用的理解的工作原理采用回调函数来处理异步编程。 JavaScript怎么使用循环代替(异步)递归 问题描述 在开发过程中,遇到一个需求:在系统初始化时通过http获取一个第三方服务器端的列表,第三方服务器提供了一个接口,可通过...

    tuniutech 评论0 收藏0
  • ES6-7

    摘要:的翻译文档由的维护很多人说,阮老师已经有一本关于的书了入门,觉得看看这本书就足够了。前端的异步解决方案之和异步编程模式在前端开发过程中,显得越来越重要。为了让编程更美好,我们就需要引入来降低异步编程的复杂性。 JavaScript Promise 迷你书(中文版) 超详细介绍promise的gitbook,看完再不会promise...... 本书的目的是以目前还在制定中的ECMASc...

    mudiyouyou 评论0 收藏0
  • 从源码看 Promise 概念实现

    摘要:从源码看概念与实现是异步编程中的重要概念,它较好地解决了异步任务中回调嵌套的问题。这些概念中有趣的地方在于,标识状态的变量如都是形容词,用于传入数据的接口如与都是动词,而用于传入回调函数的接口如及则在语义上用于修饰动词的副词。 从源码看 Promise 概念与实现 Promise 是 JS 异步编程中的重要概念,它较好地解决了异步任务中回调嵌套的问题。在没有引入新的语言机制的前提下,这...

    kel 评论0 收藏0
  • 深入理解 Promise 实现细节

    摘要:显然,了解的实现细节,可以帮助我们更好地应用它。本文将主要根据的这篇文章,探讨的实现细节。核心说明尽管已经有自己的规范,但目前的各类库,在的实现细节上是有差异的,部分甚至在意义上完全不同。到前面到为止,所实现的都是不能级联的。 在之前的异步JavaScript与Promise一文中,我介绍了Promise以及它在异步JavaScript中的使用意义。一般来说,我们是通过各种JavaSc...

    junbaor 评论0 收藏0
  • 从JS引擎理解Await b()Promise.then(b)的堆栈处理

    摘要:对于引擎来说,两者获取堆栈的方式是不同的。对于引擎来说,堆栈信息附加在了函数所返回的并在链中传递,这样函数也能在需要的时候获取堆栈信息。使用可以实时监控线上应用的错误,并获取完整的堆栈信息。 译者按: Async/Await真的只是简单的语法糖吗?No! 原文:Asynchronous stack traces: why await beats .then() 作者: Math...

    ziwenxie 评论0 收藏0

发表评论

0条评论

hlcc

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<