Promise的基本使用

最新推荐文章于 2024-03-20 11:08:51 发布
最新推荐文章于 2024-03-20 11:08:51 发布
阅读量191 收藏
点赞数
分类专栏： web前端开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42943107/article/details/102524957
版权

通过一个例子引出Promise对象

**提出一个需求:**投一个硬币，如果是正面的时候，提出表扬，如果是反面的时候，提出批评
**分析:**条件:1.正面 2.反面
由于提出表扬和惩罚都是投硬币的结果出来之后，表扬和惩罚有一个等待的过程，因此是异步的,奖励和惩罚提出来后不马上执行，需要投硬币的结果出来之后再执行
下面用定时函数描述异步
代码:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
<script>
	   //李白投一个硬币，如果是正面的时候，提出表扬，如果是反面的时候，提出批评		
        setTimeout(() => {
            //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                console.log("表扬")
            }else{
                console.log("惩罚")
            }   
        },2000)
    </script>
</body>
</html>

当李白投掷的硬币的结果为正面的时候，打印以下结果：
在这里插入图片描述
假设不只有李白一个人投硬币,杜铺也投。
代码如下

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <script>
        //李白投一个硬币，如果是正面的时候，提出表扬，如果是反面的时候，提出批评
        setTimeout(() => {
             //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                console.log("表扬冰棍")
            }else{
                console.log("惩罚跑步")
            }   
        },2000)
        //杜铺投一个硬币，如果是正面的时候，提出表扬，如果是反面的时候，提出批评
        setTimeout(() => {
            //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                console.log("表扬糖果")
            }else{
                console.log("惩罚站立")
            }   
        },2000)
    </script>
</body>
</html>

如果还有10个诗人也参与投硬币，那么还有就还要写10个定时函数。针对这种情况可以考虑封装。封装就是把代码可变的部分封装起来，对比李白和杜铺两个定时函数,他们惩罚和奖励的结果是不一样的。所以可以把输出的结果抽出来封装。

创建一个诗人硬币的一个函数，该函数会结果两个不一样的结果，一个是惩罚，一个是表扬
代码如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <script>

        //提出一个需求:李白投一个硬币，如果是正面的时候，提出表扬，如果是反面的时候，提出批评
        //分析:条件:1.正面 2.反面
        //由于提出表扬和惩罚都是投硬币的结果出来之后，表扬和惩罚有一个等待的过程，因此是异步的
        //奖励和惩罚提出来后不马上执行，需要投硬币的结果出来之后再执行
        //下面用定时函数描述异步
        //李白投一个硬币，如果是正面的时候，提出表扬，如果是反面的时候，提出批评
        setTimeout(() => {
            //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                console.log("表扬冰棍")
            }else{
                console.log("惩罚跑步")
            }   
        },2000)

        //杜铺投一个硬币，如果是正面的时候，提出表扬，如果是反面的时候，提出批评
        setTimeout(() => {
            //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                console.log("表扬糖果")
            }else{
                console.log("惩罚站立")
            }   
        },2000)

        //创建一个诗人硬币的一个函数，该函数会结果两个不一样的结果，一个是惩罚，一个是表扬
        function test(){
                setTimeout(() => {
                //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                    console.log("表扬糖果")
                }else{
                    console.log("惩罚站立")
                }   
            },2000)
        }
    </script>
</body>
</html>

哪个诗人投硬币，哪个诗人就调用test()这个函数，只有每个诗人正反面对应的结果不一样。因此对应的结果应该是传进来的。

在函数test声明两个函数作为参数，第一个参数是resolve，是解决的意思，在这里代表的是你投硬币的结果为正面时候处理的方法，第二个参数是reject，是拒绝的意思，在这里代表的是你投硬币的结果为反面时候处理的方法。

代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <script>

        //创建一个诗人硬币的一个函数，该函数会结果两个不一样的结果，一个是惩罚，一个是表扬
        function test(resolve,reject){
                setTimeout(() => {
                    //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                        // console.log("表扬糖果")
                        resolve();
                    }else{
                        // console.log("惩罚站立")
                        reject();
                    }   
            },2000)
        }

    </script>
</body>
</html>

先假设李白先投掷硬币。
给test传入函数作为参数。第一个参数代表是正面,第二个参数代表是反面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <script>
//创建一个诗人硬币的一个函数，该函数会结果两个不一样的结果，一个是惩罚，一个是表扬
        function test(resolve,reject){
                setTimeout(() => {
                    //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                        // console.log("表扬糖果")
                        resolve();
                    }else{
                        // console.log("惩罚站立")
                        reject();
                    }   
            },2000)
        }

        //先假设李白先投掷硬币。
        test(function(){
            console.log("表扬冰棍")
        },function(){
            console.log("惩罚跑步")
        })

    </script>
</body>
</html>

运行两秒后显示结果:
在这里插入图片描述
从这个例子中可以看出，函数test封装后可以接受两个回调函数，这个是李白投掷硬币，如果是杜铺投掷硬币的时候，直接调用函数test，给它传两个参数就可以了。
代码如下所示：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <script>
//创建一个诗人硬币的一个函数，该函数会结果两个不一样的结果，一个是惩罚，一个是表扬
        function test(resolve,reject){
                setTimeout(() => {
                    //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                        // console.log("表扬糖果")
                        resolve();
                    }else{
                        // console.log("惩罚站立")
                        reject();
                    }   
            },2000)
        }

        //李白投掷硬币。
        test(function(){
            console.log("表扬冰棍")
        },function(){
            console.log("惩罚跑步")
        })

        //杜铺投掷硬币。
        test(function(){
            console.log("表扬糖果")
        },function(){
            console.log("惩罚站立")
        })


    </script>
</body>
</html>

往后如果是其他的诗人投掷硬币，直接调用test函数,传两个对应的函数作为参数就可以了。

但是这个封装test的方法有一个非常大的缺陷，如果把resolve和reject的注释去掉，或者test函数里面不只有两个参数，或者两个参数不一定是函数，可能是变量等等

function test(resolve,reject,a,b,c){
                setTimeout(() => {
                    //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                        // console.log("表扬糖果")
                        resolve();
                    }else{
                        // console.log("惩罚站立")
                        reject();
                    }   
            },2000)
        }

如果这种代码没有注释给别人看，是看不懂的。不知道这些参数代表什么意思。这代码很难维护。
因此，针对这种情况，提出了Promise对象，Promise对象是一个构造函数，返回一个promise对象，是es6标准下的一个对象，专门实现异步的需求，异步的情况下可以考虑用，不一定要用。

因此，针对这种情况，可以使用es6下的Promise对象，Promise对象是一个构造函数，返回一个promise对象，是es6标准下的一个对象，专门实现异步的需求。
标准写法：

//Promise是一个构造函数，返回一个promise对象，是es6标准下的对象，实现异步的需求
        //resolve是成功的回调函数
        //reject是失败的回调函数
        var pro = new Promise((resolve,reject) => {
            
        })

Promise这个函数里面默认有两个参数resolve,reject。(参数可以改名字)，resolve代表成功的回调函数，reject代表的是失败的回调的函数。由于Promise对象的写法是固定的，即使不用注意也能知道这两个参数是什么意思

使用Promise使用诗人投硬币的方法
代码如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <script>
//Promise是一个构造函数，返回一个promise对象，是es6标准下的对象，实现异步的需求
        //resolve是成功的回调函数
        //reject是失败的回调函数
        var pro = new Promise((resolve,reject) => {
            setTimeout(() => {
                    //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                        // console.log("表扬糖果")
                        resolve();
                    }else{
                        // console.log("惩罚站立")
                        reject();
                    }   
                },2000)
        })
    </script>
</body>
</html>

这样代码是还没有执行的，只是把诗人投硬币的结果创建出来，因为promise是一个对象，要执行，需要两个方法 pro.then().catch() ,其中 .then() 代表成功的意思 。方法里面传的是一个成功的回调函数。
把pro当作axios。

如果投掷硬币是正面，表扬冰棍。如果投掷硬币是反面，惩罚跑步。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <script>
        //Promise是一个构造函数，返回一个promise对象，是es6标准下的对象，实现异步的需求
        //resolve是成功的回调函数
        //reject是失败的回调函数
        var pro = new Promise((resolve,reject) => {
            setTimeout(() => {
                    //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;
                    if(res === "resultTrue"){
                        // console.log("表扬糖果")
                        resolve();
                    }else{
                        // console.log("惩罚站立")
                        reject();
                    }   
                },2000)
        })

        //pro当做axios
        pro.then(() => {
            console.log("表扬糖果")
        })
    </script>
</body>
</html>

在这里插入图片描述
运行代码：
在这里插入图片描述
修改投掷的结果为正面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <script>
// Promise是一个构造函数，返回一个promise对象，是es6标准下的对象，实现异步的需求
        // resolve是成功的回调函数
        // reject是失败的回调函数
        var pro = new Promise((resolve,reject) => {
            setTimeout(() => {
                    //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;

                    if(res === "resultFalse"){
                        // console.log("表扬糖果")
                        resolve();
                    }else{
                        // console.log("惩罚站立")
                        reject();
                    }   
                },2000)
        })

        //pro当做axios
        pro.then(() => {
            console.log("表扬糖果")
        })
    </script>
</body>
</html>

运行代码：
在这里插入图片描述
由于方法里面没有传一个失败情况的回调函数。因此报错,也可以看出。pro的回调函数是resolve。为了当你投掷硬币的结果为反面的时候，显示结果，给pro传一个失败的回调函数catch，表示失败的回调函数。

代码:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <script>
        // Promise是一个构造函数，返回一个promise对象，是es6标准下的对象，实现异步的需求
        // resolve是成功的回调函数
        // reject是失败的回调函数
        var pro = new Promise((resolve,reject) => {
            setTimeout(() => {
                    //结果为正面
                    var res1 ="resultTrue";
                    //结果为反面
                    var res2 ="resultFalse";
                    //假设的结果
                    var res = res1;

                    if(res === "resultFalse"){
                        // console.log("表扬糖果")
                        resolve();
                    }else{
                        // console.log("惩罚站立")
                        reject();
                    }   
                },2000)
        })

        //pro当做axios
        pro.then(() => {
            console.log("表扬糖果")
        }).catch(() => {
            console.log("惩罚站立")
        })
    </script>
</body>
</html>

在这里插入图片描述
运行结果：
在这里插入图片描述
对比与之前的实现方式。Promise的实现方式， then和catch两个回调函数一看就知道then就代表成功的情况，catch代表的是失败的情况。阅读性更好！

由于这个方法只是能满足单个人投硬币使用，不能满足多个人。因此需求还没有完成。我们要的是多个人投硬币，都可以进行判断出结果。要完成这个需求，我们还要引入async和await。
async是异步的意思，await是等待的意思。这篇文章写的太长了，这个需求要到下一篇关于
async和await的文章一起完成。

webshitian
关注
专栏目录
Promise 基本使用
Celine921的博客
03-25 1598
promise 基本使用
promise基本使用
兔子零
05-07 225
基本使用 // new 做了什么 // 1. 创建一个新的空对象 // 2. 将构造函数中的this指向这个新空对象 // 3. 执行构造函数中的代码 // 4. 返回这个对象 // 5. 这个对象上有一个__proto__指向构造函数的原型 var promise = new Promise((resolve, reject) => { var flag = false if (flag)...
说说promise
qq1498982270的博客
04-28 296
你了解promise吗？ 为什么会出现promise？ 因为回调地狱： 先理解什么是回调函数？ 简单来说，回调就是等我某件事做完以后才去做回调需要做的事情 首先，回调与同步异步没有什么直接联系，回调只是一种实现方式 异步请求回调： $.get('ajax/test',function(data){ xxx }) 点击事件回调： $('#id').click(() =&g...
Promise 隔三秒打印red，再隔2秒打印green，再隔1秒打印yellow，依次循环无限打印
huang_xiao_rong的博客
03-04 931
Promise settimeout
【Vue3】报错：类型“Ref＜never[]＞”缺少类型“Composite[]”的以下属性: length, pop, push, concat 及其他 28 项。
最新发布
m0_55464684的博客
03-20 1235
用reactive代替ref。
TypeScript
xiaoxu的博客
11-28 484
文章目录变量声明基本类型 变量声明 TypeScript支持var、let、const声明变量，我们知道，JavaScript是弱类型语言，声明变量时不指定变量的数据类型，可以给变量赋予任何数据类型的值，TypeScript与JavaScript不同的是在使用var、let、const声明变量时，可以指定变量的基本类型（当然也可以不指定）。例如： var a:number; a = 123； le...
TS报错整理
imber___zsk的博客
08-31 1万+
记录一下最近项目中TS报错及解决 一.找不到模块“images/1.png”或其相应的类型声明。 报错图： 原因：TS没有识别图片模块 解决方法：加上图片格式声明模块???? 成功不报红： 二.类型“unknown”上不存在属性“data”。 同：类型“{}”上不存在属性“data”。 报错图： 原因：对象上本没有某个属性，没有语法检测到该属性（即对象属性不明确） 解决方法： 定义对象的接口，但是往往后端数据是不能确定的，这个时候使用第二种方法 将这个对象
js代码-Promise基本使用2
07-16
Promise的基本使用2主要涵盖了Promise的创建、状态转换、链式调用以及错误处理等方面。让我们深入探讨一下这些关键概念。 首先，Promise有三种状态：pending（等待中）、fulfilled（已成功）和rejected（已失败）。...
Promise基本使用及方法
kamianlaidaa的博客
05-08 823
Promise基本使用及方法 promise 是异步编程的一种解决方案，是采用链式写法用来处理由回调嵌套引起的回调地狱的问题。 promise可以看做一个包含异步操作结果的容器（成功或失败） Promise有以下几种状态：（状态不可逆） pending: 等待状态。 fulfilled: 成功状态。 rejected:失败状态。 promise初始是一个pending状态，到了一定的条件就会变成fulfilled（成功）或者rej...
promise的一点小Tip
越来越棒鸭
09-02 354
今天练习promise的时候， let p1 = new Promise((resolve, reject) => { setTimeout(() => { resolve('hello') }, 2000) }) console.log('1', p1) let p2 = new Promise((resolve, reject) => { setTimeout(() => { resolve('world') },
TypeScript学习 （第四天） 数组表示
weixin_48914823的博客
12-20 2697
用接口来表示对象，现在我们来说说数组的 5 种表示方法 1.数组 + [ ] // 1， 类型加括号表示 const arrNum: number[] = [1, 2, 3, 4] const arr: [number, string, number] = [1, '2', 3] console.log(arrNum) // [1,2,3,4] console.log(arr) // [[1, '2', 3]] arrNum.push('5') // 报错 ： 类型“string”的参数不能赋给类型“nu
Ts基础学习笔记
m0_51531365的博客
02-25 934
简介 什么是TypeScript Typed JavaScript at Any Scale. 添加了类型系统的 JavaScript，适用于任何规模的项目 安装TypeScript npm install -g typescript 编译一个 TypeScript 文件 tsc hello.ts Hello TypeScript // 将以下代码复制粘贴 function sayHello(person: string) { return 'Hello, ' + person; } let
STM32相关工具软件的使用
weixin_64520123的博客
11-18 175
⑤ 在左下方选择“DTR的低电平复位，RTS高电平进BootLoader”，FlyMCU会通过DTR和RTS信号来控制板载的一键下载功能电路，实现一键下载功能。③ 下载成功后，会出现“共写入 xxxx KB，进度100%，耗时 xxxx 毫秒”的提示，并且下方的进度条会全绿。③ 勾选“编程前重装文件”，FlyMcu会在每次编程前，将.hex文件重新装载一遍，在代码调试的时候比较有用。④ 勾选“编程后执行”，可以在下载完程序之后自动运行代码，无需再按复位键来运行代码，便于代码调试。
HAL库利用中断方式实现开关灯及串口通信
qq_59184121的博客
10-23 546
DMA，全称Direct Memory Access，即直接存储器访问。DMA传输将数据从一个地址空间复制到另一个地址空间，提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。DMA用来提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。无须CPU的干预，通过DMA数据可以快速地移动。这就节省了CPU的资源来做其他操作。1数据的源地址2数据传输位置的目标地址3传递数据多少的数据传输量4进行多少次传输的传输模式DMA特征。
【STM32学习之旅】第二篇——程序烧录方法（串口下载）
十年初心不忘
01-03 6340
一.驱动与软件准备 1.一般来说，Windows 7、8、10可以自动完成CH340等常用芯片的驱动安装。 2.使用FLYMCU绿色软件下载STM32的固件。 二.FLYMCU软件的使用 1.首先搜索串口 2.旁边Port选择串口号（串口号可在设备管理器中查看，若只有一个COM口可忽略此项） 3.选择我们要烧录的程序，为HEX或BIN文件 4.确认各选项的设置与下图相同 5.点击“开始编程”即可烧录程序，此时固件被烧录到Flash中 6.若使用RAM烧录模式，可先使STM3..
JavaScript笔记（5）
weixin_30680385的博客
12-14 194
1.return 跳出当前函数 返回一个结果 <script> //return可以跳出当前函数 所以return写在函数的最后一行 function out() { return function (){ console.log("inner-before") ...
数组的29个方法
hkduan的博客
05-03 639
数组的方法一共29个: 1.转字符：toString, join, str.split, valueOf 2.堆栈方法： push 返回增加后的长度 pop 返回删除的最后一个项目 unshift 返回增加数组的长度 shift 删除的项目 3.排序 reverse() sort随机排序 var arr = [1,2,3,4,5] arr.sort() // 从小到大 arr.sort((a,b)=>b-a) // 从大到小 arr.sort(()=> Math.rando
typescript如何解决类型“never”上不存在属性‘xxx‘问题？
热门推荐
城南蝈蝈
11-25 2万+
原文链接 0.前言 在使用angular的时候，在后台返回一段json进行处理，然后在使用的时候出现如下报错。 我考虑这个问题的由来一般是因为前面没有给这个list指定具体的属性名称，所有这个地方会报错，而且我程序运行后拿到的数据是没有问题的，但是有一点强迫症，不愿意看到爆红，所以想办法解决他。 1.解决办法 我考虑了3个方法，其中前两个是经过实践的，第三个是一个猜想。 方法1：如下图所示，直接在后面加上[“name”]这样的属性名进行调用就行了。 方法2：直接指定数据类型为 any。 方法3：前面我考
TypeScript 相关问题（含解答）
我本可以容忍阳光，如果我不曾见过太阳，然而阳光已使我荒凉，成为更新的荒凉。
08-03 1724
点击上方前端瓶子君，关注公众号回复算法，加入前端编程面试算法每日一题群给出一大些面试题，然后不给答案。前端本来就卷，一些面试官看了文章后可能在自己都不知道答案的情况下，就跑去问面试者。我...
promise基本语法
09-01
promise基本语法如下： 1. 创建Promise对象： ```javascript const promise = new Promise((resolve, reject) => { // 异步操作逻辑 }); ``` 2. 处理异步操作逻辑： 在Promise的构造函数中，执行异步操作逻辑，并根据操作结果调用`resolve`函数或`reject`函数。`resolve`用于将Promise状态设置为fulfilled（已完成），`reject`用于将Promise状态设置为rejected（已拒绝）。 3. 处理成功和失败的回调： 使用`.then()`方法处理Promise成功完成的情况，使用`.catch()`方法处理Promise被拒绝的情况。 ```javascript promise.then((result) => { // 成功完成的回调函数 }).catch((error) => { // 失败的回调函数 }); ``` 4. 链式调用： 可以通过多次调用`.then()`方法来实现Promise的链式调用，每次调用返回一个新的Promise对象。 ```javascript promise.then((result) => { // 第一个then回调 return anotherAsyncOperation(result); }).then((result) => { // 第二个then回调 return yetAnotherAsyncOperation(result); }).catch((error) => { // 失败的回调函数 }); ``` 以上是Promise基本语法的简单示例。在实际应用中，可以根据具体需求进行更复杂的操作和错误处理。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值