promise对象使用

最新推荐文章于 2024-11-27 16:41:27 发布

皇家小骑士

最新推荐文章于 2024-11-27 16:41:27 发布

阅读量337

点赞数 1

分类专栏：前端文章标签： promise对象使用

本文链接：https://blog.youkuaiyun.com/qq_41866776/article/details/102808353

版权

前端专栏收录该内容

8 篇文章

订阅专栏

promise对象使用

大量的异步操作，如果要顺序执行的话，则会形成回调地狱，通过promise对象，即可解决回调地狱。
以node为例，假设我们有一个需求
1.判断test.txt是否存在，不存在则输出错误
2.若存在则删除这个文件
3.写入一个新的文件
假如不用promise对象，代码如下

const fs=require('fs')
fs.stat('./test.txt',(err,states)=>{
    if(err){
        console.log(err)
    }else{
   		console.log("文件存在")
        fs.unlink('./test.txt',(err)=>{
            if(err){
                console.log(err)
            }else{
                console.log("文件删除成功")
                fs.writeFile('./test1.txt','HelloWorld',(err)=>{
                    if(err){
                        console.log(err)
                    }else{
                        console.log("新文件写入成功")
                        //若有更多的操作则继续在这写，形成回调地狱
                    }
                })
            }
        })
    }
})

当操作顺序执行的操作越多的时候，便会一直写回调，形成回调地狱。此时引入promise对象即可解决这个问题。
promise的构造函数中包含两个参数，resolve-成功之后的回调函数，reject-失败之后的回调函数。

const promise=new promise((resolve,reject)=>{
	if(/*异步操作成功*/){
		resolve()//可以传参,传入.then(msg)
	}else{
		reject()//可以传参,传入.then(err)
	}
})

当实例生成后，.then()指定resolve的回调函数，.catch指定reject的回调函数。
用promise对象重写上述例子

const fs = require('fs')
//将每个Promise对象封装成函数，返回Promise对象
//判断文件是否存在
function isExit() {
    return new Promise((resolve, reject) => {
        fs.stat('./test.txt', (err) => {
            if (err) {
                reject('err1')
            } else {
                resolve('文件存在')
            }
        })
    })
}

function deleteF() {
    return new Promise((resolve, reject) => {
        fs.unlink('./test.txt', (err) => {
            if (err) {
                reject('err2')
            } else {
                resolve('文件删除成功')
            }
        })
    })
}

function writeF() {
    return new Promise((resolve, reject) => {
        fs.writeFile('./test1.txt', 'HelloWorld', (err) => {
            if (err) {
                reject('err3')
            } else {
                resolve('新文件写入成功')
            }
        })
    })
}
//链式操作,所有错误共用一个catch
isExit()
    .then((msg) => {
        console.log(msg)
        return deleteF()
    })
    .then((msg) => {
        console.log(msg)
        return writeF()
    })
    .then((msg) => {
        console.log(msg)
    })
    .catch((err) => {
        console.log(err)
    })

若要中断链式操作，则抛出一个错误信息即可

isExit()
    .then((msg) => {
        console.log(msg)
        return deleteF()
    })
    .then((msg) => {
        console.log(msg)
        return writeF()
    })
    .then((msg) => {
        console.log(msg)
    })
    .then(()=>{
        console.log('这是多余的操作，但是要存在，下一个then不执行')
		//抛出错误信息中断下一个操作
        throw new Error('停止输出')
    })
    .then(()=>{
        console.log('看看我输出来了吗')
    })
    .catch((err) => {
        console.log(err)
    })

输出结果

文件存在
文件删除成功
新文件写入成功
这是多余的操作，但是要存在，下一个then不执行
Error: 停止输出
    at isExit.then.then.then.then