Асинхронная функция, эквивалентная обещанию

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 узла pre async-await эры).

Answer 1

Вот как мне нравится писать async / await , это довольно просто.Весь код внутри может быть прочитан как синхронизация. РЕДАКТИРОВАТЬ : ожидание будет работать, только если API вернет объект обещания, который либо разрешен, либо отклонен. await не выполняет обещания.

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

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);
	})

Он не нарушает ваш код, если вы используете шаблон fn (). Then.catch в Promise, возвращающем асинхронное объединение.
Однако использование await делает его более элегантным,

Не стесняйтесь ссылаться на подробную статью, которую я написал об основах async-await и почему async-await по сравнению с шаблоном .then.catch, плюсы и минусы здесь: https://github.com/cskru/asyncAwaitSimplified

Я включил фрагменты кода, которые вы можете напрямую скопировать вставить и попробовать.

PS: Я использовал асинхронный IIFE в приведенных выше фрагментах.
Это связано с тем, что ожидания могут быть сделаны только внутри асинхронной функции / контекста.

Я бы также порекомендовал вам проверить эту статью , чтобы получить прочную основу для асинхронного ожидания.

Счастливого обучения!

Ура,
Крутика

Answer 3

При переходе на асинхронное / ожидание, что меняется не в настройке вашего обещания, а в том, как вы делаете вызовы на свои обещания.Например:

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

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

Имейте в виду, что для функции, которую использует await, необходимо установить значение async.

---

Если ваш someNodeApi вызов уже был настроен для обещаний, тогда результат будет точно таким же, вам просто не понадобится aFunction.Например, если вы использовали многообещающую библиотеку в вашем API, тогда вам вообще не нужен aFunction.

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

// or

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