Упрощение асинхронного кодирования с помощью асинхронных функций

 async function doAsyncOp () {
  try {
    var val = await asynchronousOperation();
    val = await asynchronousOperation(val);
    return await asynchronousOperation(val);
  } catch (err) {
    console.err(err);
  }
};

Это не так кратко, как другие преобразования в асинхронные функции, но это именно то, как вы бы делали это с синхронным кодом. Если вы не уловите ошибку здесь, она будет всплывать до тех пор, пока не будет обнаружена в функциях вызывающей стороны, или она просто не будет перехвачена, и вы завершите выполнение с ошибкой времени выполнения. Обещания работают так же, за исключением того, что отказы не должны быть ошибками; они могут быть просто строкой, объясняющей, что пошло не так. Если вы не уловите отклонение, созданное с ошибкой, то вы увидите ошибку времени выполнения, но если вы просто используете строку, то она молча завершится неудачей.

Нарушенные обещания

Чтобы отклонить собственное обещание, вы можете использовать rejectPromisePromisethencatch Если ошибка выходит за пределы этой области, она не будет содержаться в обещании.

Вот несколько примеров способов отклонения обещаний:

 function doAsyncOp() {
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      reject("something is bad");
    }
    resolve("nothing is bad");
  });
}

/*-- or --*/

function doAsyncOp() {
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      reject(new Error("something is bad"));
    }
    resolve("nothing is bad");
  });
}

/*-- or --*/

function doAsyncOp() {
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      throw new Error("something is bad");
    }
    resolve("nothing is bad");
  });
}

Как правило, лучше всего использовать new Error

Вот несколько примеров, когда обещание не поймает ошибку:

 function doAsyncOp() {
  // the next line will kill execution
  throw new Error("something is bad");
  return new Promise(function(resolve, reject) {
    if (somethingIsBad) {
      throw new Error("something is bad");
    }
    resolve("nothing is bad");
  });
}

// assume `doAsyncOp` does not have the killing error
function x() {
  var val = doAsyncOp().then(function() {
    // this one will work just fine
    throw new Error("I just think an error should be here");
  });
  // this one will kill execution
  throw new Error("The more errors, the merrier");
  return val;
}

При использовании асинхронных функций обещания отклоняются из-за ошибок. Проблема с областью не возникает — вы можете выдать ошибку в любом месте асинхронной функции, и она будет поймана обещанием:

 async function doAsyncOp() {
  // the next line is fine
  throw new Error("something is bad");
  if (somethingIsBad) {
    // this one is good too
    throw new Error("something is bad");
  }
  return "nothing is bad";
} 

// assume `doAsyncOp` does not have the killing error
async function x() {
  var val = await doAsyncOp();
  // this one will work just fine
  throw new Error("I just think an error should be here");
  return val;
}

Конечно, мы никогда не вернемся к этой второй ошибке или к returndoAsyncOp

Gotchas

Если вы новичок в асинхронных функциях, нужно знать, что нужно использовать вложенные функции. Например, если у вас есть другая функция в вашей асинхронной функции (обычно как обратный вызов чего-либо), вы можете подумать, что вы можете просто использовать await Ты не можешь Вы можете использовать awaitasync

Например, это не работает:

 async function getAllFiles(fileNames) {
  return Promise.all(
    fileNames.map(function(fileName) {
      var file = await getFileAsync(fileName);
      return parse(file);
    })
  );
}

await Вместо этого к функции обратного вызова должно быть прикреплено ключевое слово async

 async function getAllFiles(fileNames) {
  return Promise.all(
    fileNames.map(async function(fileName) {
      var file = await getFileAsync(fileName);
      return parse(file);
    })
  );
}

Это очевидно, когда вы видите это, но, тем не менее, это то, что вам нужно остерегаться.

Если вам интересно, вот эквивалент использования обещаний:

 function getAllFiles(fileNames) {
  return Promise.all(
    fileNames.map(function(fileName) {
      return getFileAsync(fileName).then(function(file) {
        return parse(file);
      });
    })
  );
}

Следующий вопрос касается людей, думающих, что асинхронные функции являются синхронными функциями. Помните, что код внутри асинхронной функции будет работать так, как если бы он был синхронным, но он все равно немедленно вернет обещание и позволит другому коду выполняться вне его, пока он работает для выполнения. Например:

 var a = doAsyncOp(); // one of the working ones from earlier
console.log(a);
a.then(function() {
  console.log("`a` finished");
});
console.log("hello");

/* -- will output -- */
Promise Object
hello
`a` finished

Вы можете видеть, что асинхронные функции все еще используют встроенные обещания, но они делают это изнутри. Это дает нам возможность мыслить синхронно внутри асинхронной функции, хотя другие могут вызывать наши асинхронные функции с помощью обычного API Promise или с помощью собственных асинхронных функций.

Лучший асинхронный код сегодня!

Даже если вы не можете использовать его изначально, вы можете написать его и использовать инструменты для его компиляции в ES5. Асинхронные функции предназначены для того, чтобы сделать ваш код более читабельным и, следовательно, более понятным. Пока у нас есть исходные карты, мы всегда можем работать с более чистым кодом ES2017.

Существует несколько инструментов, которые могут компилировать асинхронные функции (и другие функции ES2015 +) вплоть до кода ES5. Если вы используете Babel , это просто установка предустановки ES2017 .

Вы уже пользуетесь удивительной силой, которую нам дают асинхронные функции? Это то, что вы хотели бы использовать сегодня? Дайте нам знать об этом в комментариях.