ฉันจะใช้ 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; คุณต้องจัดการข้อยกเว้นการปฏิเสธ / async ตามสัญญาเนื่องจากไม่มีสิ่งใดเกิดขึ้น คุณไม่มีผู้โทรเพื่อส่งต่อให้ หากคุณต้องการคุณสามารถทำเช่นนั้นกับผลลัพธ์ของการโทรผ่าน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ฟังก์ชั่น wrapper ระดับบนสุด(# 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การเรียกไปยัง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 ได้เพิ่มการสนับสนุนในโมดูล

มันสนับสนุนโดยDeno (ตามความเห็นของ gonzalo-bahamondez)

ทางออกที่แท้จริงของปัญหานี้คือแนวทางที่แตกต่าง

อาจเป็นไปได้ว่าเป้าหมายของคุณคือการเริ่มต้นบางอย่างซึ่งมักเกิดขึ้นที่ระดับสูงสุดของแอปพลิเคชัน

การแก้ปัญหาคือเพื่อให้แน่ใจว่ามีคำสั่ง JavaScript เพียงคำเดียวเดียวเท่านั้นที่ระดับสูงสุดของแอปพลิเคชันของคุณ หากคุณมีคำสั่งเดียวที่ด้านบนสุดของแอปพลิเคชันของคุณคุณสามารถใช้ async / รอได้ที่จุดอื่น ๆ ทุกที่ทุกเวลา (ขึ้นอยู่กับหลักสูตรไปจนถึงกฎไวยากรณ์ปกติ)

ใส่อีกวิธีหนึ่งห่อระดับสูงสุดทั้งหมดของคุณไว้ในฟังก์ชันเพื่อไม่ให้อยู่ในระดับสูงสุดอีกต่อไปและแก้ปัญหาการเรียกใช้ 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!');
}

สิ่งสำคัญที่ควรทราบคือว่าฟังก์ชั่นที่เกิดขึ้นไม่ใช่ฟังก์ชั่น async ดังนั้นคุณจึงไม่สามารถใช้คำศัพท์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แท็กเพื่อติดตั้ง typescript 3.8 รุ่นล่าสุด

ตั้งแต่main()ทำงานแบบอะซิงโครนัสส่งคืนสัญญา คุณต้องได้รับผลลัพธ์ในthen()วิธีการ และเนื่องจากการthen()ส่งคืนสัญญาเช่นกันคุณต้องโทรprocess.exit()เพื่อสิ้นสุดโปรแกรม

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