ES6中Promise的原理解析

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了ES6中Promise的原理解析，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含3389字，纯文字阅读大概需要5分钟。

内容图文

转载于原文地址：https://blog.csdn.net/u013217071/article/details/76911627

简介

Promise 对象用于延迟(deferred) 计算和异步(asynchronous )计算。一个Promise对象代表着一个还未完成，但预期将来会完成的操作。Promise 对象是一个返回值的代理，这个返回值在promise对象创建时未必已知。它允许你为异步操作的成功或失败指定处理方法。这使得异步方法可以像同步方法那样返回值：异步方法会返回一个包含了原返回值的 promise 对象来替代原返回值。

解决了什么问题及怎么使用

            //
             一个简单的示例 执行一个动画A，执行完之后再去执行另一个动画B
            setTimeout(function(){
    
            //
            A动画
    console.log(‘A‘);
    setTimeout(function() {
        //B动画
        console.log(‘B‘);
    },300)
},300);
// 这里只有两个动画，如果有更多呢，就会看到一堆函数缩进

不难想象，如果依次有很多个动画，就会出现多重嵌套。代码不是纵向发展，而是横向发展，很快就会乱成一团，无法管理。

因为多个异步操作形成了强耦合，只要有一个操作需要修改，它的上层回调函数和下层回调函数，可能都要跟着修改。这种情况就称为回调函数地狱“（callback hell）。

Promise 对象就是为了解决这个问题而提出的。它不是新的语法功能，而是一种新的写法，允许将回调函数的嵌套，改成链式调用。

Promise 的最大问题是代码冗余，原来的任务被 Promise 包装了一下，不管什么操作，一眼看去都是一堆then，原来的语义变得很不清楚。

（1）浏览器实现方式可以在支持Promise的版本上运行

            var p = new Promise(function (resolve, reject) {
    setTimeout(function () {
        // A动画
        console.log(‘A‘);
        resolve();
    }, 300);
});

p.then(function () {
    setTimeout(function () {
        // B动画
        console.log(‘B‘);
    }, 300);
});

（2）另一种写法（jQuery版本）

            var deferred = $.Deferred();
setTimeout(function(){
  // A动画
  console.log(‘A‘);
  deferred.resolve();
},300);

deferred.done(function() {
  setTimeout(function() {
    // B动画
    console.log(‘B‘);
  },300)
});

promise会让代码变得更容易维护，像写同步代码一样写异步代码。

promise原理

其实，promise就是三个状态。利用观察者模式，只需要通过特定书写方式注册对应状态的事件处理函数，然后更新状态，调用注册过的处理函数即可。

这个特定方式就是then，done，fail，always…等方法，更新状态就是resolve、reject方法。

下面简单实现：

            /*
            *
    /**
      * [3种状态]
      * @type {String}
     
            */
            var PENDING = "pending";
var RESOLVED = "resolved";
var REJECTED = "rejected";
/**
 * [Promise类实现]
 * 构造函数传入一个fn，有两个参数，resolve：成功回调; reject：失败回调;
 * state: 状态存储
 * doneList: 成功处理函数列表
 * failList: 失败处理函数列表
 * done: 注册成功处理函数
 * fail: 注册失败处理函数
 * then: 同时注册成功和失败处理函数
 * always: 一个处理注册到成功和失败，都会调用
 * resolve: 更新state为：RESOLVED，并且执行成功处理队列
 * reject: 更新state为：REJECTED，并且执行失败处理队列
*/var Promise2 = (function () {
    var noop = function () { }
    function Promise(fn) {
        this.state = PENDING;
        this.doneList = [];
        this.failList = [];
        this.fn = fn;
        this.fn(this.resolve.bind(this), this.reject.bind(this)) //立即执行构造函数的第一个参数    }
    var p = {
        done: function (cb) {

            if (typeof cb == "function")
                this.doneList.push(cb)
            returnthis;
        },
        fail: function (cb) {
            if (typeof cb == "function")
                this.failList.push(cb);
            returnthis;
        },
        then: function (success, fail) {
            this.done(success || noop).fail(fail || noop)
            returnthis;
        },
        always: function (cb) {
            this.done(cb).fail(cb)
            returnthis;
        },
        resolve: function () {
            this.state = RESOLVED;
            var lists = this.doneList;
            for (var i = 0; i < lists.length;) {
                lists[i].apply(this, arguments);
                lists.shift();
            }
            returnthis;
        },
        reject: function () {
            this.state = REJECTED;
            var lists = this.failList;
            for (var i = 0; i < lists.length;) {
                lists[0].apply(this, arguments);
                lists.shift();
            }
            returnthis;
        }
    }
    for (var k in p) {
        Promise.prototype[k] = p[k]
    }
    return Promise;
})();
//测试代码var p1 = new Promise2(function (resolve, reject) {
    setTimeout(resolve, 2000);
    console.log(‘p1‘, new Date);
});
p1.then(function () {
    console.log("end", new Date);
}).always(function () {
    console.log(‘always‘, new Date);
});

利用观察者模式，只需要通过特定书写方式，注册对应状态的事件处理函数，然后更新状态，调用注册过的处理函数即可。

解释：当我们调用new Promise(fn)时，就会立即执行第一个参数fn。上面案例中，先将then(done,fail)对应的回调函数分别加入到doneList或者failList中，always中对应的参数同时加到doneList和failList中；

当异步代码执行完毕，就调用resolve方法，此时改变promise的状态为resolved，并执行doneList里面的回调函数。如果执行失败，则调用fail方法，此时改变promise的状态为rejected，并执行failList里面的回调函数。

原文：https://www.cnblogs.com/minigrasshopper/p/9141307.html

内容总结

以上是互联网集市为您收集整理的ES6中Promise的原理解析全部内容，希望文章能够帮你解决ES6中Promise的原理解析所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1310785.html

来源：【匿名】

【上一篇】ES6之函数参数【下一篇】ES6系列之声明变量let与const

更多 ►

【ES6中Promise的原理解析】教程文章相关的互联网学习教程文章

es6 Promise对象【图】

（为啥用promise）基本用法Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。一个简单的例子原文：https://www.cnblogs.com/huancheng/p/10565054.html

转载于原文地址：https://blog.csdn.net/u013217071/article/details/76911627简介Promise 对象用于延迟(deferred) 计算和异步(asynchronous )计算。一个Promise对象代表着一个还未完成，但预期将来会完成的操作。Promise 对象是一个返回值的代理，这个返回值在promise对象创建时未必已知。它允许你为异步操作的成功或失败指定处理方法。这使得异步方法可以像同步方法那样返回值：异步方法会返回一个包含了原返回值的 promise 对象...

ES6新增特性——Promise【代码】

一：为什么会出现？1、场景一：在很多业务需求中，你需要通过ajax进行多次请求，而且每次请求返回的数据需要作为参数进行下一次的请求，于是会出现ajax层层嵌套问题。多个请求操作层层依赖，加上每一层还会有复杂的业务逻辑需要处理，使得代码可读性很差，不直观，难以维护和调试。注：这种回调函数层层嵌套又称为回调地狱//请求A $.ajax({success:function (res1) {//请求B $.ajax({success:function (res2) {//请求...

ES6语法 Promise Iterator【代码】【图】

类和对象基本定义：class Parent{constructor(name=‘lmx‘){ //name= 默认值 this.name=name} } let v_parent = new Parent(‘v‘); console.log(v_parent); //输出Parent {name: "v"}继承class Parent{constructor(name=‘lmx‘){this.name=name} } class Child extends Parent{constructor(name=’child’){super(name); //如果super中没有参数则都按照父类的默认值 } } console.log(new Child())getter和setterclass Pa...

ES6 Promise 用法讲解【代码】【图】

Promise是一个构造函数，自己身上有all、reject、resolve这几个眼熟的方法，原型上有then、catch等同样很眼熟的方法。那就new一个var p = new Promise(function(resolve, reject){//做一些异步操作setTimeout(function(){console.log(‘执行完成‘);resolve(‘随便什么数据‘);}, 2000); });Promise的构造函数接收一个参数，是函数，并且传入两个参数：resolve，reject，分别表示异步操作执行成功后的回调函数和异步操作执行失败后...

es6中的promise对象

promise对象，用来传递异步操作的消息。它代表了某个未来才会知道结果的事件（通常是一个异步操作），并且这个事件提供统一的API。promise对象有两个特点：1.对象的状态不受外界影响。promise对象代表一个异步操作，有3种状态：pending（进行种），resolved（已完成,又称fulfilled），rejected（已失败）。只有异步操作的结果可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是"promise"这个名字的由来，它在英语中...

ES6 Promise 用法讲解(转)【代码】【图】

Promise是一个构造函数，自己身上有all、reject、resolve这几个眼熟的方法，原型上有then、catch等同样很眼熟的方法。 var p = new Promise(function(resolve, reject){ //做一些异步操作 setTimeout(function(){ console.log(‘执行完成‘); resolve(‘随便什么数据‘); }, 2000);}); Promise的构造函数接收一个参数，是函数，并且传入两个参数：resolve，reject，分别表示异步操作执行成功后的回调函数和...

深入理解es6中的Promise

https://www.jianshu.com/p/9e4af5b77253 https://zhuanlan.zhihu.com/p/30797777原文：https://www.cnblogs.com/zuobaiquan01/p/10792325.html

es6 promise的使用【图】

Promise.all()的使用打印结果原文：https://www.cnblogs.com/malong1992/p/12129301.html

ES6中的Promise对象的理解【图】

Promise的含义promise是异步编程的一种解决方法。所谓promise，简单说是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果，从语法上说，promise是一个对象，从它可以获取异步操作的消息，promise提供了统一的API，各种异步操作都可以用同样的方法进行处理。Promise对象的特点（1）对象的状态不受外界影响，promise对象代表一个异步操作，有三种状态，pending（进行中）、fulfilled（已成功）、rejected（已...

es6中promise ALL Race Resolve Reject finish的实现【代码】

function mypromise(func){this.statue = "pending";this.data = null;this.resolveCallback = [];this.rejectCallback = [];this._final = null;var self = this;var resolve = function(data){if (data instanceof mypromise) {data.then(resolve,reject)return;}setTimeout(function(){if(self.statue != "pending") return;self.data = data;self.statue = "resolve";for(var i = 0; i < self.resolveCallback.length; i++){va...

ES6 Promise 对象【代码】

es6 Promise 对象是异步编程的一种解决方案。（在javascript世界里，是单线程顺序执行的）从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。Promise 异步操作有三种状态：pending（进行中）、fulfilled（已成功）和 rejected（已失败）。除了异步操作的结果，任何其他操作都无法改变这个状态。Promise 对象只有：从 pending 变为 fulfilled 和从 pending 变为 rejected 的状态改变。只要处于 fulfilled 和 rejected ，...

ES6 class setTimeout promise async/await 测试Demo【代码】

class Person {async getVersion () {returnnew Promise((resolve, reject) => {setTimeout(function () {resolve(‘1.0‘); // reject(‘fail‘)}, 1000);})} }const start = async () => {var p = new Person();const data = await p.getVersion();console.log(20180716090040, data); }start(); // 20180716090040 "1.0" 原文：https://www.cnblogs.com/CyLee/p/9315997.html

ES6语法——Promise对象【代码】

一、概念　　Promise是异步编程的一种解决方案（解决回调地狱的问题），是一个能够获取异步操作信息的对象。Promise的内部保存着某个未来才会结束的事件（通常是一个异步操作）二、特点　　1.Promise对象的状态不受外界影响　　　　Promise对象的状态由异步操作的结果决定当前处于pending（进行中）、fulfilled（已成功）还是rejected（已失败），任何其他操作都无法改变这个状态。　　2.状态改变不可逆　　　　一旦状态改变，就不...

ES6 Promise 对象【代码】【图】

es6 Promise 对象是异步编程的一种解决方案。（再javascript世界里，是单线程顺序执行的）从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。 Promise 异步操作有三种状态：pending（进行中）、fulfilled（已成功）和 rejected（已失败）。除了异步操作的结果，任何其他操作都无法改变这个状态。Promise 对象只有：从 pending 变为 fulfilled 和从 pending 变为 rejected 的状态改变。只要处于 fulfilled 和 rejected ...

首页 / ES6 / ES6中Promise的原理解析