Альтернативы

Альтернатива этому:

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 миллионов бросков в секунду в одном однопоточном процессе. Если вы делаете больше, возможно, вам стоит об этом побеспокоиться.

Резюме

Я бы не стал беспокоиться о подобных вещах в 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
  }
}

Альтернативой блоку try-catch является await-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)
}

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

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

Я предпочитаю обернуть все в большой блок try-catch, в котором создается несколько обещаний, что может затруднить обработку ошибки специально для создавшего ее обещания. Альтернативой является несколько блоков try-catch, которые я считаю одинаково громоздкими

Более чистой альтернативой будет следующее:

Из-за того, что каждая асинхронная функция технически является обещанием

Вы можете добавлять уловки к функциям при их вызове с помощью await

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

Нет необходимости в try catch, так как все ошибки обещаний обрабатываются, и у вас нет ошибок кода, вы можете опустить это в родительском элементе !!

Допустим, вы работаете с mongodb, если есть ошибка, вы можете предпочесть обработать ее в вызывающей ее функции, а не создавать оболочки или использовать уловки try.

Я бы хотел так сделать :)

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 Такое поведение, по моему опыту, опасно. Будет обнаружена любая ошибка, возникшая во всем стеке, а не только ошибка из этого обещания (что, вероятно, не то, что вам нужно).

Второй аргумент обещания - это уже обратный вызов отказа / отказа. Лучше и безопаснее использовать это вместо этого.

Вот однострочный текст, который я написал, чтобы справиться с этим:

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