Як я можу використовувати async / чакати на найвищому рівні?

Я перебирав 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-й етап, тож відповідь на ваше запитання Як я можу використовувати асинхронізацію / очікувати на найвищому рівні? це просто додати 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 .

v8 додала підтримку в модулях.

Його також підтримує Дено (як коментує gonzalo-bahamondez).

Актуальним рішенням цієї проблеми є підхід до неї по-різному.

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

Рішення полягає в тому, щоб переконатися, що на найвищому рівні вашої програми завжди залишається одне єдине твердження JavaScript. Якщо у вас є лише одне твердження у верхній частині вашої програми, ви можете вільно використовувати async / очікувати в будь-якій іншій точці будь-де (будь-коли, за умови нормальних синтаксичних правил)

По-іншому, загортайте весь верхній рівень у функцію, щоб вона більше не була верхньою, і це вирішує питання про те, як запустити асинхронізацію / очікувати на верхньому рівні програми - ви цього не зробите.

Ось як має виглядати верхній рівень вашої програми:

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