promise讲解

作者 : 开心源码 本文共6258个字,预计阅读时间需要16分钟 发布时间: 2022-05-13 共231人阅读

promise 简介

Promise是ES6加入标准的一种异步编程处理方案,通常用来表示一个异步操作的最终完成 (或者失败)。Promise标准的提出,处理了JavaScript地狱回调的问题。

语法

var p = new Promise( function(resolve, reject) {...} /* executor */  );p.then(() => {})  // 成功resolve.catch(()=> {});   // 失败reject

构造函数

Promise构造函数executor 函数, resolve 和 reject 两个函数作为参数传递给executor(executor 函数在Promise构造函数返回所建 promise 实例对象前被调用)。resolve 和 reject 函数被调用时,分别将promise的状态改为fulfilled(完成)或者rejected(失败)。executor 内部通常会执行少量异步操作,一旦异步操作执行完毕(可能成功/失败),要么调用resolve函数来将promise状态改成fulfilled,要么调用reject 函数将promise的状态改为rejected。假如在executor函数中抛出一个错误,那么该promise 状态为rejected。executor函数的返回值将被忽略。

形容

Promise对象在创立之后,并不肯定会马上就有值,只是一个代理商结果,它存在三种状态:

  • pending: 初始状态(等待状态),既不是成功,也不是失败状态。
  • fulfilled: 意味着操作成功完成。
  • rejected: 意味着操作失败完成。

方法

Promise.all(iterable)

这个方法返回一个新的 promise 对象。一般该方法会接受一个iterable参数,里面是一个promise列表,当所有的promise都触发成功时才会触发成功,一旦有一个失败了,则会马上中止其余promise的执行。当iterable里面的结果都执行成功了,这个新的promise对象会将所有的结果已数组的形式依次返回。当有一个失败是,这个新的promise对象会将失败的信息返回。

Promise.race(iterable)

当 iterable 参数里的任意一个子 promise 被成功或者失败后,父 promise 马上也会用子 promise 的成功返回值或者失败介绍作为参数调用父 promise 绑定的相应句柄,并返回该 promise 对象。

Promise.reject(rease)

返回一个状态为失败的 Promise 对象,并将给定的失败信息传递给对应的解决方法

Promise.resolve(value)

返回一个状态由给定 value 决定的 Promise 对象。假如该值是 thenable(即,带有 then 方法的对象),返回的 Promise 对象的最终状态由 then 方法执行决定;否则的话(该 value 为空,基本类型或者者不带 then 方法的对象),返回的 Promise 对象状态为 fulfilled,并且将该 value 传递给对应的 then 方法。通常而言,假如你不知道一个值能否是 Promise 对象,使用 Promise.resolve(value) 来返回一个 Promise 对象,这样就能将该 value 以 Promise 对象形式使用。

实例

枯燥的说明终于结束了,下面用一个具体的实例来展现各种状态和方法:

// 创立promise1,构造函数有2个参数resolve,rejectconst p1 = new Promise((resolve, reject) => {    console.log('我一开始就会执行!')    setTimeout(() => {        resolve('timeout 1')    }, 1000)})// promise2const p2 = new Promise((resolve, reject) => {    setTimeout(() => {        resolve('timeout 2')    }, 2000)})console.log(p1, p2, 'p1, p2状态')// Promise.race方法,任何一个成功或者失败就会执行then方法Promise.race([p1, p2]).then(res => {    console.log(res, 'race结果')})// Promise.all方法Promise.all([p1, p2]).then(res => {    console.log(res, 'all结果')    console.log('此时:', p1, p2, 'p1, p2状态')})// Promise.reject方法测试Promise.reject('失败').catch(err => console.log('Promise.reject:' + err))// Promise.resolve方法测试Promise.resolve(1).then(r => console.log('Promise.resolve的结果1:' + r))Promise.resolve(p1).then(r => console.log('Promise.resolve的结果2:' + r))

1.png
上面的代码和执行结果简单的说明了Promise创立,存在状态和方法的使用。下面再详细详情Promise的使用方法。

promise 的使用方法

本文一开始就提出,Promise能处理前台臭名昭著的地狱回调问题,那什么是地狱回调呢?这里简单拿一个场景和实现方法来解释一下:

场景

前台很常见是下面一个场景,我们需要实现一个客户修改头像的功能。首先我们需要将一张图片压缩并提交给后台,后台返回该图片保存的 url,前台拿保存的 url 和客户 id 提交给服务器来修改客户头像。

  1. 异步一:加载图片
  2. 异步二:压缩图片
  3. 异步三:上传图片
  4. 异步四:提交保存

大概代码实现:

// 读取头像,异步过程,成功之后执行回调函数function readImg(callback) {    const img = new Image();    img.onload = function () {        callback && callback(img)    }}// 压缩一张图片,压缩过程异步,成功之后执行回调函数function compression(img, callback) {    zipImg(img, callback)}// 上次客户头像,异步请求function uploadImg(img, callback) {    $.ajax({        url: '/upload',        data: img,        success: function (url) {            callback && callback(url)        }    })}// 保存最终数据,客户头像,异步请求function saveData(url, callback) {    $.ajax({        url: '/save',        data: {id, url},        success: function (res) {            callback && callback(res)        }    })}// 保存函数function submit() {    readImg(function (img) {        compression(img, function (img) {            uploadImg(img, function (url) {                saveData(url, function (res) {                    console.log(res)                })            })        })    })}

上面的场景在我们开发的过程中很常见,由于js的异步特性,异步执行结果只能在回调函数里面才能拿到,所以就有了最终的回调地狱。这个过程异常极难排查,而且一层一层嵌套,代码极难维护也不美观。利用promise链式调用(chaining)的特点,我们可以将上面的代码改成下面的形式:

function submit() {    readImg().then(img => {        return compression(img)    }).then(img => {        return uploadImg(img)    }).then(url => {        return saveData(url)    }).then(res => {        console.log(res)    }).catch(err => {        console.log(err)    })}

可以看到代码结构不仅变成平铺的了,异常解决也变得简单了,只要要最后catch一个异常,就能捕获整个过程的异常。

用法

promise 创立

变量的的方式创立:

const myFirstPromise = new Promise((resolve, reject) => {  // ?做少量异步操作,最终会调用下面两者之一:  //   resolve(someValue); // fulfilled  // ?或者  //   reject("failure reason"); // rejected});myFirstPromise.then(res =>{    // 成功doSomething}).catch(err => {  // 失败doSomething})

函数的方式创立:

const myFirstPromise = function() {    return new Promise((resolve, reject) => {        // 一个异步过程        // resolve() 成功 fulfilled        // reject()  失败  rejected    })}myFirstPromise().then(res =>{    // 成功doSomething}).catch(err => {  // 失败doSomething})

使用场景

在异步时,给出异步后的结果:

const myFirstPromise = function() {    return new Promise((resolve, reject) => {        setTimeout(() => {            resolve()        },1000)    })}myFirstPromise.then(()=>{    console.log('一秒后!')})

多个异步都需要结果才往下执行时,使用promise.all:

Promise.all([func1(), func2(), func3()]).then(([result1, result2, result3]) => { /* use result1, result2 and result3 */ });

顺序执行一组异步,拿到最后的结果,使用Promise.resolve和reduce函数结合来实现:

var funca = function (a) {    return new Promise((resolve, reject) => {        setTimeout(() => {            console.log(a, 'result funca');            resolve(a + 1)        }, 1000)    })}var funcb = function (result) {    return new Promise((resolve, reject) => {        setTimeout(() => {            console.log(result, 'result funcb')            resolve(2 + result)        }, 1000)    })}var funcc = function(result) {    return new Promise((resolve, reject) => {        setTimeout(() => {            console.log(result, 'result funcc')            resolve(3 + result)        }, 1000)    })}var funcd = function(d) {    console.log(d, 'result funcd')    return d + 4}const applyAsync = (acc,val) => acc.then(val);const composeAsync = (...dd) => x => dd.reduce(applyAsync, Promise.resolve(x));const transformData = composeAsync(funca, funcb, funcc, funcd);transformData(1).then(result => console.log(result,'last result')).catch(e => console.log(e));

执行结果
上面 3 个异步函数和一个同步函数,我们利用Promise.resolve的特性,顺序执行了 3 个异步函数,最后在then里面取到了最后的执行结果。而且上面的函数是可复用的,能顺序执行任意数量的异步函数和同步函数。

常见错误写法

在编写 Promise 链时,需要注意以下示例中展现的几个错误:

// 错误示例,包含 3 个问题!doSomething().then(function(result) {  doSomethingElse(result) // 没有返回 Promise 以及没有必要的嵌套 Promise  .then(newResult => doThirdThing(newResult));}).then(() => doFourthThing());// 最后,是没有使用 catch 终止 Promise 调用链,可能导致没有捕获的异常

第一个错误是没有正确地将事物相连接。当我们创立新 Promise 但不记得返回它时,会发生这种情况。因而,链条被打破,或者者更确切地说,我们有两个独立的链条竞争(同时在执行两个异步而非一个一个的执行)。这意味着 doFourthThing() 不会等待 doSomethingElse() 或者 doThirdThing() 完成,并且将与它们并行运行,可能是无意的。单独的链也有单独的错误解决,导致未捕获的错误。

第二个错误是不必要地嵌套,实现第一个错误。嵌套还限制了内部错误解决程序的范围,假如是非预期的,可能会导致未捕获的错误。其中一个变体是 Promise 构造函数反模式,它结合了 Promise 构造函数的多余使用和嵌套。

第三个错误是不记得用 catch 终止链。这导致在大多数浏览器中不能终止的 Promise 链里的 rejection。

一个好的经验法则是总是返回或者终止 Promise 链,并且一旦你得到一个新的 Promise,返回它。下面是修改后的平面化的代码:

doSomething().then(function(result) {  return doSomethingElse(result);}).then(newResult => doThirdThing(newResult)).then(() => doFourthThing()).catch(error => console.log(error));

兼容性

兼容性
大多数浏览器已经支持了promise,在babel的加持下,我们无需担心。

总结

  1. Promise是ES6加入标准的一种异步编程处理方案,通常用来表示一个异步操作的最终完成 (或者失败)。
  2. promise链式调用的特点,处理了js地狱回调的问题。
  3. promise提供了一系列属性和方法。正当利用Promise.all和Promise.resolve可以处理不少问题。

写在最后

下期会结合本期的讲解,配合少量经典的promise面试题来更深入的理解promise。毕竟promise太重要,太好用了。
后面会有async/await和promise的讲解。

参考资料:

promise 使用指南

相关阅读:

前台异步是什么?哪些情况下会发生异步?

知道html5 Web Worker标准吗?能实现JavaScript的多线程?

学习如逆水行舟,不进则退,前台技术飞速发展,假如每天不坚持学习,就会跟不上,我会陪着大家,每天坚持推送博文,跟大家一同进步,希望大家能关注我,第一时间收到最新文章。

公众号前台每日面试题分享:

公众号

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » promise讲解

发表回复