Я копаюсь у функцію асинхрон / очікування вузла 7 і продовжую натикатися на такий код

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 / wait, проте 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а потім роздруковує його, якщо обіцянка була вирішена, або викидає виняток і запускає блок лову, який друкує помилку, якщо обіцянку було відхилено.

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

Підсумок

Я б не турбувався про подібні речі в Node. Якщо подібні речі звикають багато, то з часом V8 або SpiderMonkey або Chakra будуть оптимізовані, і всі будуть слідувати - це не так, як це не оптимізовано як принцип, це просто не проблема.

Навіть якщо це не оптимізовано, я все-таки стверджую, що якщо ви максимізуєте свій процесор у Node, то, ймовірно, ви повинні записати свій номер, який розсипається в C - ось для чого, серед іншого, і є рідні аддони. А може, такі речі, як node.native , краще підійдуть для роботи, ніж Node.js.

Мені цікаво, який би був корисний випадок, коли потрібно кинути стільки винятків. Зазвичай викидання виключення замість повернення значення - це, ну, виняток.

Альтернатива, аналогічна поводженню з помилками в Golang

Оскільки async / await використовує обіцянки під кришкою, ви можете написати невелику функцію утиліти, як це:

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

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

import catchEm from 'utility';

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

Альтернативою блоку спробу ловлі є lib очікування до js . Я часто його використовую. Наприклад:

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);

}

Цей синтаксис набагато чіткіше порівняно з пробним уловом.

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 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, якщо виникла помилка, ви можете скористатися функцією, яка викликає її, ніж виготовлення обгортки або використання пробного лову.

Я хотів би зробити так :)

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Інфікування таким чином, на мій досвід, небезпечно. Будь-яка помилка, викинута на весь стек, буде зафіксована, а не лише помилка з цієї обіцянки (що, мабуть, не те, що ви хочете).

Другий аргумент обіцянки - це вже відкликання / відмова відмови. Краще і безпечніше використовувати це замість цього.

Ось такий шрифт typesafe, який я написав для цього:

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