Question

我有一个函数可以返回promise，如下所示：

let aFunction= function(){
    return new Promise((resolve, reject){
       someNodeApi(params, function(err, data)) {
          if(err) {
            return reject(err);
          }
          if(data meets certain criteria) {
             someOtherNodeApi(params, function(err, data)) {
                // handle conditions.
             }
          }
          resolve(data);
       }         
    })
}

我想拥有一个与这种功能等效的async功能。简而言之，我需要这样的东西：

let aFunction = async function(){
   someNodeApi(params, function(err, data){
      if(err) {
          // reject condition
      }
      // resolve condition.
   })
}

因此，在reject和resolve条件之上应该是什么，以便所有我调用该函数的地方都像这样：

aFunction()
  .then(data=>{})
  .catch(err=>{})

它应该保持不变。

编辑

我必须澄清我的问题不是关于如何调用异步函数的问题。但是它关于如何转换一个返回Promise的函数，从而能够使用async-await模式的优点，而不必修改其调用方式。（在处理异步等待时代之前的节点js代码时，这是一种非常常见的情况。）

Answer 1

这就是我喜欢编写 async / await 的方式，这使得它非常简单。里面的所有代码都可以作为同步读取。 EDIT ：仅当API返回已解决或拒绝的Promise对象时，等待才有效。等待不能解决承诺。

function someAPI() {
    return new Promise((resolve, reject)=>{
      someNodeApi(params, function(err, data){
            if(err) {
                reject(error)
            } else {
              resolve(data)
            }
            // resolve condition.
        })
    });
  }


async function aFunction() {
  try {
    const result = await someAPI();
    return result;
  } catch(err){
    console.log(err);
  }
}

aFunction()
.then((res) => console.log(res))

Answer 2

更改为异步/等待时，更改不是您的诺言设置，而是您如何调用诺言。例如：

aFunction()
  .then(data=>{})
  .catch(err=>{})

// becomes
try{
  const data = await aFunction()
}catch(err){
  // do something with err
}

请记住，需要将使用的功能设置为async。

如果您的someNodeApi呼叫已经被设置为Promise，那么结果仍然是完全一样的，您根本不需要aFunction。例如，如果您在api上使用了一个混杂的库，则根本不需要aFunction。

someNodeApi(params)
  .then(data => {})
  .catch(err => {})

// or

const data = await someNodeApi(params)
if(data meets certain criteria) {
   const otherData = someOtherNodeApi(params)
}

Answer 3

Snippet1：在这里，您可以看到async-await的用法

let fn = async function(a) {
	let val = 10;
	return new Promise((resolve, reject) => {
		if(a > val) {
			resolve("+++++Resolved");
		}
		else {
			reject("++++++Rejected")
		}
	})
};

(async () => {
	try {
		let result1 = await fn(20);
		console.log(result1);

		let result2 = await fn(5);
		console.log(result2);
	}
	catch(err) {
		console.error(err);
	}
    
})();

Snippet2：在这里您可以看到使用.then.catch不会损害或破坏您的任何代码。

let fn = async function(a) {
	let val = 10;
	return new Promise((resolve, reject) => {
		if(a > val) {
			resolve("+++++Resolved");
		}
		else {
			reject("++++++Rejected")
		}
	})
};

fn(20).then(response => {
	console.log(response);
});

fn(5)
	.then(response => {
		console.log(response);
	})
	.catch(err => {
		console.error(err);
	})

如果在Promise返回异步功能上使用fn（）。then.catch模式，它不会破坏您的代码。
但是，使用await使其更加优雅。

请随意参考我撰写的有关以下内容的详细文章：异步等待以及为什么将异步等待与.then.catch模式进行比较，优点缺点：https://github.com/cskru/asyncAwaitSimplified

我提供了一些代码片段，您可以直接复制粘贴并进行尝试。

PS：我在以上代码段中使用了异步IIFE。
这是因为只能在异步函数/上下文中进行等待。

我还建议您检查此article以便为async-await奠定坚实的基础。

学习愉快！

干杯，
克鲁西卡

相当于Promise的异步功能

3 个答案: