ฉันกำลังขุดเข้าไปในโหนด 7 คุณลักษณะ async / await และยังคงสะดุดกับโค้ดเช่นนี้

function getQuote() {
  let quote = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
  return quote;
}

async function main() {
  try {
    var quote = await getQuote();
    console.log(quote);
  } catch (error) {
    console.error(error);
  }
}

main();

นี่ดูเหมือนจะเป็นไปได้เพียงวิธีเดียวที่จะแก้ไข / ปฏิเสธหรือส่งคืน / โยนด้วย async / await อย่างไรก็ตาม v8 ไม่ได้ปรับโค้ดให้เหมาะสมภายในบล็อก try / catch ?!

มีทางเลือกอื่นไหม?

ทางเลือก

อีกทางเลือกหนึ่งสำหรับสิ่งนี้:

async function main() {
  try {
    var quote = await getQuote();
    console.log(quote);
  } catch (error) {
    console.error(error);
  }
}

จะเป็นแบบนี้โดยใช้คำสัญญาอย่างชัดเจน:

function main() {
  getQuote().then((quote) => {
    console.log(quote);
  }).catch((error) => {
    console.error(error);
  });
}

หรืออะไรทำนองนี้โดยใช้สไตล์การส่งต่อแบบต่อเนื่อง:

function main() {
  getQuote((error, quote) => {
    if (error) {
      console.error(error);
    } else {
      console.log(quote);
    }
  });
}

ตัวอย่างต้นฉบับ

สิ่งที่รหัสเดิมของคุณทำคือระงับการดำเนินการและรอให้สัญญาที่ส่งกลับมาgetQuote()เพื่อชำระ จากนั้นดำเนินการต่อและเขียนค่าที่ส่งคืนไปvar quoteแล้วพิมพ์หากคำสัญญาได้รับการแก้ไขหรือโยนข้อยกเว้นและเรียกใช้บล็อก catch ที่พิมพ์ข้อผิดพลาดหากคำสัญญาถูกปฏิเสธ

คุณสามารถทำสิ่งเดียวกันโดยใช้ Promise API ได้โดยตรงเหมือนในตัวอย่างที่สอง

ประสิทธิภาพ

ตอนนี้สำหรับการแสดง มาทดสอบกัน!

ฉันเพิ่งเขียนรหัสนี้ - f1()ให้1เป็นค่าส่งคืนf2()โยน1เป็นข้อยกเว้น:

function f1() {
  return 1;
}

function f2() {
  throw 1;
}

ตอนนี้ขอเรียกรหัสเดียวกันล้านครั้งก่อนด้วยf1():

var sum = 0;
for (var i = 0; i < 1e6; i++) {
  try {
    sum += f1();
  } catch (e) {
    sum += e;
  }
}
console.log(sum);

จากนั้นเปลี่ยนf1()เป็นf2():

var sum = 0;
for (var i = 0; i < 1e6; i++) {
  try {
    sum += f2();
  } catch (e) {
    sum += e;
  }
}
console.log(sum);

นี่คือผลลัพธ์ที่ฉันได้รับสำหรับf1:

$ time node throw-test.js 
1000000

real    0m0.073s
user    0m0.070s
sys     0m0.004s

นี่คือสิ่งที่ฉันได้รับสำหรับf2:

$ time node throw-test.js 
1000000

real    0m0.632s
user    0m0.629s
sys     0m0.004s

ดูเหมือนว่าคุณสามารถทำบางอย่างเช่น 2 ล้านครั้งต่อวินาทีในกระบวนการเธรดเดียว หากคุณทำมากกว่านั้นคุณอาจต้องกังวลเกี่ยวกับเรื่องนี้

สรุป

ฉันจะไม่กังวลเกี่ยวกับสิ่งต่างๆเช่นนั้นในโหนด หากสิ่งต่างๆเช่นนี้ถูกนำไปใช้มากมันจะได้รับการปรับให้เหมาะสมที่สุดโดยทีม V8 หรือ SpiderMonkey หรือ Chakra และทุกคนจะปฏิบัติตาม - ไม่ใช่ว่ามันไม่ได้รับการปรับให้เหมาะสมตามหลักการมันก็ไม่ใช่ปัญหา

แม้ว่าจะไม่ได้รับการปรับให้เหมาะสมฉันก็ยังคงเถียงว่าหากคุณใช้ CPU สูงสุดใน Node คุณก็ควรเขียนจำนวนของคุณใน C - นั่นคือสิ่งที่ส่วนเสริมดั้งเดิมมีไว้สำหรับสิ่งอื่น ๆ หรือบางทีสิ่งต่างๆเช่นnode.nativeจะเหมาะกับงานมากกว่า Node.js

ฉันสงสัยว่าจะเป็นกรณีการใช้งานที่ต้องทิ้งข้อยกเว้นมากมาย โดยปกติแล้วการโยนข้อยกเว้นแทนที่จะส่งคืนค่าคือข้อยกเว้น

ทางเลือกที่คล้ายกับการจัดการข้อผิดพลาดใน Golang

เนื่องจาก async / await ใช้คำสัญญาภายใต้ประทุนคุณจึงสามารถเขียนฟังก์ชันยูทิลิตี้เล็ก ๆ น้อย ๆ ดังนี้:

export function catchEm(promise) {
  return promise.then(data => [null, data])
    .catch(err => [err]);
}

จากนั้นนำเข้าเมื่อใดก็ตามที่คุณต้องการตรวจจับข้อผิดพลาดและรวมฟังก์ชัน async ของคุณซึ่งจะส่งคืนสัญญาด้วย

import catchEm from 'utility';

async performAsyncWork() {
  const [err, data] = await catchEm(asyncFunction(arg1, arg2));
  if (err) {
    // handle errors
  } else {
    // use data
  }
}

อีกทางเลือกหนึ่งในการลองจับบล็อกคือawa-to-js lib ฉันมักจะใช้มัน ตัวอย่างเช่น:

import to from 'await-to-js';

async function main(callback) {
    const [err,quote] = await to(getQuote());
    
    if(err || !quote) return callback(new Error('No Quote found'));

    callback(null,quote);

}

ไวยากรณ์นี้สะอาดกว่ามากเมื่อเทียบกับ try-catch

async function main() {
  var getQuoteError
  var quote = await getQuote().catch(err => { getQuoteError = err }

  if (getQuoteError) return console.error(err)

  console.log(quote)
}

หรืออีกวิธีหนึ่งแทนที่จะประกาศ var ที่เป็นไปได้เพื่อระงับข้อผิดพลาดที่ด้านบนคุณสามารถทำได้

if (quote instanceof Error) {
  // ...
}

แม้ว่าจะไม่ได้ผลหากมีข้อผิดพลาดเช่น TypeError หรือ Reference ถูกโยนทิ้ง คุณสามารถมั่นใจได้ว่าเป็นข้อผิดพลาดปกติแม้ว่าจะมี

async function main() {
  var quote = await getQuote().catch(err => {
    console.error(err)      

    return new Error('Error getting quote')
  })

  if (quote instanceOf Error) return quote // get out of here or do whatever

  console.log(quote)
}

ความชอบของฉันสำหรับสิ่งนี้คือการรวมทุกอย่างไว้ในบล็อกลองจับขนาดใหญ่ที่มีการสร้างคำสัญญาหลายสัญญาทำให้ยุ่งยากในการจัดการข้อผิดพลาดเฉพาะกับสัญญาที่สร้างขึ้น ด้วยอีกทางเลือกหนึ่งคือการลองจับหลายบล็อกซึ่งฉันคิดว่ายุ่งยากพอ ๆ กัน

ทางเลือกที่สะอาดกว่ามีดังต่อไปนี้:

เนื่องจากความจริงที่ว่าทุกฟังก์ชัน async เป็นสัญญาทางเทคนิค

คุณสามารถเพิ่มการจับเพื่อฟังก์ชั่นเมื่อเรียกใช้โดยรอ

async function a(){
    let error;

    // log the error on the parent
    await b().catch((err)=>console.log('b.failed'))

    // change an error variable
    await c().catch((err)=>{error=true; console.log(err)})

    // return whatever you want
    return error ? d() : null;
}
a().catch(()=>console.log('main program failed'))

ไม่จำเป็นต้องลองจับเนื่องจากข้อผิดพลาดของสัญญาทั้งหมดจะได้รับการจัดการและคุณไม่มีข้อผิดพลาดของรหัสคุณสามารถละเว้นสิ่งนั้นในผู้ปกครองได้ !!

สมมติว่าคุณกำลังทำงานกับ mongodb หากมีข้อผิดพลาดคุณอาจต้องการจัดการกับฟังก์ชันที่เรียกมันมากกว่าการทำ wrapper หรือใช้การลองจับ

อยากทำแบบนี้ :)

const sthError = () => Promise.reject('sth error');

const test = opts => {
  return (async () => {

    // do sth
    await sthError();
    return 'ok';

  })().catch(err => {
    console.error(err); // error will be catched there 
  });
};

test().then(ret => {
  console.log(ret);
});

คล้ายกับการจัดการข้อผิดพลาดกับ co

const test = opts => {
  return co(function*() {

    // do sth
    yield sthError();
    return 'ok';

  }).catch(err => {
    console.error(err);
  });
};

catchในแบบนี้จากประสบการณ์ของฉันมันอันตราย ข้อผิดพลาดใด ๆ ที่เกิดขึ้นในสแต็กทั้งหมดจะถูกจับได้ไม่ใช่แค่ข้อผิดพลาดจากสัญญานี้ (ซึ่งอาจไม่ใช่สิ่งที่คุณต้องการ)

อาร์กิวเมนต์ที่สองของคำสัญญาเป็นการเรียกกลับแบบปฏิเสธ / ล้มเหลว จะดีกว่าและปลอดภัยกว่าถ้าใช้แทน

นี่คือ typescript typesafe one-liner ที่ฉันเขียนเพื่อจัดการสิ่งนี้:

function wait<R, E>(promise: Promise<R>): [R | null, E | null] {
  return (promise.then((data: R) => [data, null], (err: E) => [null, err]) as any) as [R, E];
}

// Usage
const [currUser, currUserError] = await wait<GetCurrentUser_user, GetCurrentUser_errors>(
  apiClient.getCurrentUser()
);