Nodejs promise应该如何书写带有分支的异步操作

Nodejs promise应该如何书写带有分支的异步操作

最近努力理解promise遇到了一个问题： 对于如下带有分支的异步操作

asyncFunc1(arg,function(e,res){
	if(res){
		asycnFunc2(arg,function(e,res){
			cb(null,res);
		})
	}else{
		cb(null,false);
	}
});

转换成promise的格式应该怎么写呢？

感谢


3 回复

当然可以。为了将你提供的带有分支的异步操作转换为使用 Promise 的形式，我们需要利用 Promise 对象来处理异步逻辑，并且通过 then 和 catch 方法来处理不同的分支。

以下是如何将你的代码转换为使用 Promise 的格式：

原始代码

asyncFunc1(arg, function (e, res) {
    if (res) {
        asyncFunc2(arg, function (e, res) {
            cb(null, res);
        });
    } else {
        cb(null, false);
    }
});

使用 Promise 的版本

我们可以先将 asyncFunc1 和 asyncFunc2 包装成返回 Promise 的函数，然后通过 .then() 和 .catch() 来处理分支逻辑。

1. 将异步函数包装成返回 Promise 的函数

function asyncFunc1Promise(arg) {
    return new Promise((resolve, reject) => {
        asyncFunc1(arg, (err, res) => {
            if (err) {
                reject(err);
            } else {
                resolve(res);
            }
        });
    });
}

function asyncFunc2Promise(arg) {
    return new Promise((resolve, reject) => {
        asyncFunc2(arg, (err, res) => {
            if (err) {
                reject(err);
            } else {
                resolve(res);
            }
        });
    });
}

2. 使用 Promise 处理分支逻辑

asyncFunc1Promise(arg)
    .then(res => {
        if (res) {
            return asyncFunc2Promise(arg);
        } else {
            return Promise.resolve(false); // 直接返回一个表示失败的 Promise
        }
    })
    .then(result => {
        cb(null, result);
    })
    .catch(err => {
        cb(err, null);
    });

解释

  • asyncFunc1Promise 和 asyncFunc2Promise 是将原始回调风格的异步函数转换为返回 Promise 的函数。
  • .then() 方法用于处理成功的情况，如果 asyncFunc1 返回的结果为 true，则继续执行 asyncFunc2Promise，否则直接返回 false。
  • .catch() 方法用于捕获任何可能发生的错误。

这样，我们就将原始的回调风格代码转换成了更现代、更易于管理和理解的 Promise 风格代码。


asyncFunc1Promise arg
.then ([res])->
	if !res
		throw 'end'
	asycnFunc2Promise arg
.then ([res])->
	doSomething()
.done ([result])->
	doSomething()
, (err)->
	if err=='end'
		return	doOtherThings()
	errorHander()

为了将带有分支的异步操作转换为使用 Promise 的形式，我们可以利用 Promise 的链式调用来实现。以下是将你的代码转换为使用 Promise 的示例：

function asyncFunc1(arg) {
    return new Promise((resolve, reject) => {
        // 假设 asyncFunc1 是一个异步函数，它接受一个回调作为参数
        asyncFunc1(arg, (err, res) => {
            if (err) reject(err);
            else resolve(res);
        });
    });
}

function asyncFunc2(arg) {
    return new Promise((resolve, reject) => {
        // 假设 asyncFunc2 是一个异步函数，它接受一个回调作为参数
        asyncFunc2(arg, (err, res) => {
            if (err) reject(err);
            else resolve(res);
        });
    });
}

// 使用 Promise 处理分支逻辑
asyncFunc1(arg)
    .then(res => {
        if (res) {
            return asyncFunc2(arg);
        } else {
            return false;
        }
    })
    .then(result => {
        // 处理最终结果
        console.log(result);
    })
    .catch(err => {
        // 处理错误
        console.error('Error:', err);
    });

在这段代码中，我们首先将 asyncFunc1 和 asyncFunc2 转换为返回 Promise 的函数。然后，我们使用 .then() 方法来处理异步操作的结果，并根据结果进行不同的分支处理。如果 asyncFunc1 返回的结果为真值，则继续执行 asyncFunc2；否则直接返回 false。最后，我们使用 .catch() 来捕获并处理可能出现的任何错误。

这种方式使得异步代码更易于理解和维护。

回到顶部