ES2017 - Асинхронность против доходности

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

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

• * обозначает функцию генератора, которая всегда будет возвращать генератор, который может быть расширен (и остановлен) извне, потребляя его аналогично итератору.
• async обозначает асинхронную функцию, которая всегда будет возвращать обещание, которое зависит от других обещаний и чье выполнение выполняется одновременно с другими асинхронными операциями (и может быть отменено извне).

Это правда, что ключевое слово не является строго необходимым, и тип функции может определяться тем, появляются ли в ее теле соответствующие ключевые слова (_5 _ / _ 6_), но это привело бы к менее удобному в сопровождении коду:

• менее понятен, потому что нужно сканировать все тело, чтобы определить вид
• более подвержен ошибкам, потому что легко сломать функцию, добавив / удалив эти ключевые слова, не получая синтаксической ошибки

обычная функция, выполнение которой будет ждать завершения тела отверстия, пока не будут выполнены все ожидания

Похоже, вам нужна функция блокировки, что является очень плохой идеей в параллельной настройке. .

Помечая функцию как async, вы говорите JS всегда возвращать обещание.

Поскольку он всегда возвращает Promise, он также может ждать для обещаний внутри своего собственного блока. Представьте, что это одна гигантская цепочка обещаний - то, что происходит внутри функции, эффективно закрепляется на ее внутреннем .then() блоке, а то, что возвращается, является последним .then() в цепочке.

Например, эта функция ...

async function test() {
  return 'hello world';
}

... возвращает обещание. Таким образом, вы можете выполнить его как единое целое, .then() и все такое.

test().then(message => {
  // message = 'hello world'
});

So...

async function test() {
  const user = await getUser();
  const report = await user.getReport();
  report.read = true
  return report;
}

Примерно аналогично ...

function test() {
  return getUser().then(function (user) {
    return user.getReport().then(function (report) {
      report.read = true;
      return report;
    });
  });
}

В обоих случаях обратный вызов, переданный в test().then(), получит report в качестве первого параметра.

Генераторы (т. Е. Маркировка функции * и использование ключевого слова yield) - это совсем другое понятие. Они не используют обещания. Они эффективно позволяют вам «прыгать» между различными частями вашего кода, выдавая результат изнутри функции, а затем возвращаясь к этой точке и возобновляя выполнение следующего блока yield.

Хотя они кажутся чем-то похожими (т.е. «останавливают» выполнение до тех пор, пока что-то не произойдет где-то еще), async/await только дает вам эту иллюзию, потому что нарушает внутренний порядок выполнения обещаний. Это не на самом деле ожидание - это просто перетасовка, когда происходят обратные вызовы.

Генераторы, напротив, реализованы по-другому, так что генератор может поддерживать состояние и повторяться. Опять же, ничего общего с обещаниями.

Граница еще больше размыта, потому что на текущий момент поддержка async / await пугает; Chakracore изначально поддерживает его, и Скоро это будет у V8. Тем временем транспиляторы, такие как Babel, позволяют писать async/await и преобразовывать код в генераторы . Ошибочно заключать, что генераторы и async / await, следовательно, одинаковы; они не ... просто так получилось, что вы можете ублюдать, как yield работает вместе с обещаниями, чтобы получить аналогичный результат.

Обновление: ноябрь 2017 г.

Node LTS теперь имеет встроенную поддержку async/await, поэтому вам никогда не нужно использовать генераторы для имитации обещаний.

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

Причина в том, что это был действующий JS до ES7.

function await(x) {
  return 'awaiting ' + x
}

function foo() {
  return(await(42))
}

Согласно вашей логике, foo() вернет Promise{42} или "awaiting 42"? (возврат обещания нарушит обратную совместимость)

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

Интересный факт: исходная спецификация предлагала более легкий function^ foo() {} синтаксис async.

Причина ключевого слова async впереди проста, поэтому вы знаете, что возвращаемое значение будет преобразовано в обещание. Если нет ключевого слова, как бы переводчик узнал об этом. Я думаю, что это было впервые введено в C #, и EcmaScript берет добычу из TypeScript. TypeScript и C # разработаны Андерсом Хейлсбергом и похожи друг на друга. скажем, у вас есть функция (это просто для асинхронной работы)

 function timeoutPromise() {  
     return (new Promise(function(resolve, reject) {
         var random = Math.random()*1000;
         setTimeout(
             function() {
                 resolve(random);
             }, random);
     }));
 }

эта функция заставит нас ждать случайное время и вернуть объект Promise (если вы используете jQuery, обещание похоже на Deferred). Чтобы использовать эту функцию сегодня, вы должны написать что-то вроде этого

function test(){
    timeoutPromise().then(function(waited){
        console.log('I waited' + waited);
    });
}

И это нормально. Теперь давайте попробуем вернуть сообщение журнала

function test(){
    return timeoutPromise().then(function(waited){
        var message = 'I waited' + waited;
        console.log(message);
        return message; //this is where jQuery Deferred is different then a Promise and better in my opinion
    });
}

Хорошо, это неплохо, но в коде есть два оператора возврата и функция.

Теперь с async это будет выглядеть так

  async function test(){
      var message = 'I waited' +  (await timeoutPromise());
      console.log(message);
      return message;
  }

Код короткий и встроенный. Если вы написали много .then () или. done () вы знаете, насколько нечитаемым может стать код.

Теперь почему ключевое слово async перед функцией. Это означает, что ваше возвращаемое значение - это не то, что возвращается. Теоретически вы могли бы написать это (это можно сделать на C #, я не знаю, разрешит ли js, поскольку это еще не сделано).

 async function test(wait){
     if(wait == true){
         return await timeoutPromise();
     }
     return 5;                
 }

вы видите, вы возвращаете число, но фактический возврат будет Promise, который вам не нужно использовать return new Promise(function(resolve, reject) { resolve(5);}; Поскольку вы не можете ожидать числа, только Promise await test(false) вызовет исключение, а await test(true) не будет, если вы не укажете async спереди.