Как я могу использовать async / await на верхнем уровне?

Я перебирал async/ awaitпосле того, как просмотрел несколько статей, я решил проверить себя сам. Тем не менее, я не могу обернуться, почему это не работает:

async function main() {  
    var value = await Promise.resolve('Hey there');
    console.log('inside: ' + value);
    return value;
}

var text = main();  
console.log('outside: ' + text);

Консоль выводит следующее (узел v8.6.0):

> снаружи: [обещание объекта]

> Внутри: Привет

Почему сообщение журнала внутри функции выполняется позже? Я думал, что причина async/ awaitбыла создана для того, чтобы выполнить синхронное выполнение с использованием асинхронных задач.

Есть ли способ я могу использовать значение, возвращенное внутри функции без использования .then()после main()?

Кажется, я не могу понять, почему это не работает.

Потому что mainвозвращает обещание; все asyncфункции делают.

На верхнем уровне вы должны либо:

1. Используйте функцию верхнего уровня, asyncкоторая никогда не отклоняет (если вы не хотите ошибок «необработанного отклонения»), или

2. Используйте thenи catch, или

3. (Скоро!) Используйте верхнего уровняawait , предложение, достигшее стадии 3 в процессе, который позволяет использование верхнего уровня awaitв модуле.

# 1 - asyncфункция верхнего уровня, которая никогда не отклоняет

(async () => {
    try {
        var text = await main();
        console.log(text);
    } catch (e) {
        // Deal with the fact the chain failed
    }
})();

Обратите внимание на catch; вы должны обрабатывать обещания отклонения / асинхронные исключения, так как больше ничего не происходит; у вас нет звонящего, чтобы передать их. Если вы предпочитаете, вы можете сделать это в результате вызова через catchфункцию (вместо try/ catchсинтаксис):

(async () => {
    var text = await main();
    console.log(text);
})().catch(e => {
    // Deal with the fact the chain failed
});

... что немного более кратко (мне нравится по этой причине).

Или, конечно, не обрабатывать ошибки, а просто допустить ошибку «необработанное отклонение».

№ 2 - thenиcatch

main()
    .then(text => {
        console.log(text);
    })
    .catch(err => {
        // Deal with the fact the chain failed
    });

catchОбработчик будет вызываться при возникновении ошибок в цепи или в thenобработчике. (Убедитесь, что ваш catchобработчик не генерирует ошибки, так как ничего не зарегистрировано для их обработки.)

Или оба аргумента then:

main().then(
    text => {
        console.log(text);
    },
    err => {
        // Deal with the fact the chain failed
    }
);

Снова обратите внимание, что мы регистрируем обработчик отклонения. Но в этой форме, будьте уверены, что ни один из ваших thenобратных вызовов не выдает никаких ошибок, ничего не зарегистрировано для их обработки.

# 3 верхнего уровня awaitв модуле

Вы не можете использовать awaitна верхнем уровне скрипта без модуля, но на высшем уровне awaitпредложение ( этап 3 ) позволяет использовать его на верхнем уровне модуля. Это похоже на использование asyncоболочки функций верхнего уровня (# 1 выше) в том смысле, что вы не хотите, чтобы ваш код верхнего уровня отклонял (выдавал ошибку), потому что это приведет к необработанной ошибке отклонения. Поэтому, если вы не хотите иметь необработанное отклонение, когда что-то пойдет не так, как в случае с # 1, вы захотите обернуть свой код в обработчик ошибок:

// In a module, once the top-level `await` proposal lands
try {
    var text = await main();
    console.log(text);
} catch (e) {
    // Deal with the fact the chain failed
}

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

Верхний уровеньawait перешел на этап 3, поэтому ответ на ваш вопрос Как я могу использовать async / await на верхнем уровне? это просто добавить awaitвызов к main():

async function main() {  
    var value = await Promise.resolve('Hey there');
    console.log('inside: ' + value);
    return value;
}

var text = await main();  
console.log('outside: ' + text)

Или просто:

const text = await Promise.resolve('Hey there');
console.log('outside: ' + text)

Имейте в виду, что он по-прежнему доступен только в Webpack@v5.0.0-alpha.15 .

Если вы используете TypeScript , он появился в 3.8 .

В версии 8 добавлена ​​поддержка модулей.

Это также поддерживается Дено (как прокомментировал Гонсало-Бахамондез).

Фактическое решение этой проблемы заключается в том, чтобы подойти к ней по-другому.

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

Решение состоит в том, чтобы на верхнем уровне вашего приложения был только один единственный оператор JavaScript. Если у вас есть только один оператор в верхней части вашего приложения, тогда вы можете свободно использовать async / await в любой другой точке в любом месте (при условии, конечно, нормальных правил синтаксиса)

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

Вот как должен выглядеть верхний уровень вашего приложения:

import {application} from './server'

application();

Чтобы дать некоторую дополнительную информацию поверх текущих ответов:

Содержимое node.jsфайла в настоящее время объединяется в виде строки, чтобы сформировать тело функции.

Например, если у вас есть файл test.js:

// Amazing test file!
console.log('Test!');

Затем node.jsтайно объединит функцию, которая выглядит следующим образом:

function(require, __dirname, ... a bunch more top-level properties) {
  // Amazing test file!
  console.log('test!');
}

Главное, что следует отметить, это то, что результирующая функция НЕ является асинхронной функцией. Таким образом, вы не можете использовать термин awaitнепосредственно внутри него!

Но скажем, вам нужно работать с обещаниями в этом файле, тогда есть два возможных метода:

1. Не используйте await непосредственно внутри функции
2. Не использовать await

Вариант 1 требует, чтобы мы создали новую область (и ЭТА область может быть async, потому что у нас есть контроль над ней):

// Amazing test file!
// Create a new async function (a new scope) and immediately call it!
(async () => {
  await new Promise(...);
  console.log('Test!');
})();

Вариант 2 требует от нас использования объектно-ориентированного API обещаний (менее привлекательная, но в равной степени функциональная парадигма работы с обещаниями)

// Amazing test file!
// Create some sort of promise...
let myPromise = new Promise(...);

// Now use the object-oriented API
myPromise.then(() => console.log('Test!'));

Лично я надеюсь, что, если это работает, node.js по умолчанию объединит код в asyncфункцию. Это избавило бы от этой головной боли.

Ожидание верхнего уровня - это особенность грядущего стандарта EcmaScript. В настоящее время вы можете начать использовать его с TypeScript 3.8 (в настоящее время в версии RC).

Как установить TypeScript 3.8

Вы можете начать использовать TypeScript 3.8, установив его из npm, используя следующую команду:

$ npm install typescript@rc

В настоящее время вам необходимо добавить rcтег для установки последней версии 3.8.

Поскольку main()работает асинхронно, он возвращает обещание. Вы должны получить результат в then()методе. И потому что then()обещание возврата тоже, вы должны позвонить, process.exit()чтобы закончить программу.

main()
   .then(
      (text) => { console.log('outside: ' + text) },
      (err)  => { console.log(err) }
   )
   .then(() => { process.exit() } )