私はノード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 / awaitで解決/拒否または復帰/スローする唯一の可能性のようですが、v8はtry / catchブロック内のコードを最適化しませんか？

代替案はありますか？

代替案

これの代替：

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

明示的にpromiseを使用すると、次のようになります。

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 quotepromiseが解決された場合はそれを出力するか、例外をスローして、promiseが拒否された場合にエラーを出力するcatchブロックを実行します。

2番目の例のように、Promise APIを直接使用して同じことを行うことができます。

パフォーマンス

さて、パフォーマンスのために。テストしてみましょう！

私はこのコードを書いたところです- 戻り値としてf1()与え、例外としてスローします：1f2()1

function f1() {
  return 1;
}

function f2() {
  throw 1;
}

今度は同じコードを100万回呼び出しましょう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

1つのシングルスレッドプロセスで200万スローを1秒にスローするようなことができるようです。それ以上のことをしている場合は、心配する必要があるかもしれません。

概要

Nodeではそのようなことは心配しません。このようなものが頻繁に使用されると、V8、SpiderMonkey、またはChakraチームによって最終的に最適化され、誰もがフォローします。原則として最適化されていないようではなく、単に問題ではありません。

それが最適化されていない場合でも、NodeでCPUを最大限に活用している場合は、Cで数値を計算する必要があると私は主張します。これが、ネイティブアドオンの目的です。あるいは、node.nativeのようなものがNode.jsよりもジョブに適しているでしょう。

非常に多くの例外をスローする必要があるユースケースは何でしょうか。通常、値を返す代わりに例外をスローすることは、例外です。

Golangのエラー処理に似た代替手段

async / awaitは内部でpromiseを使用するため、次のような小さなユーティリティ関数を作成できます。

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

その後、いくつかのエラーをキャッチする必要があるときにそれをインポートし、それを使用してpromiseを返す非同期関数をラップします。

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

これに対する私の好みは、作成されている複数のpromiseが存在する大きなtry-catchブロックですべてをラップすることであり、それを作成したpromiseに固有のエラーを処理するのが面倒になります。代わりに、私も同じように扱いにくい複数の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'))

すべてのpromiseエラーが処理され、コードエラーがないので、catchを試行する必要はありません。親では省略できます。

mongodbで作業しているとしましょう。エラーが発生した場合は、ラッパーを作成したり、try catchを使用したりするよりも、関数を呼び出して処理する方が好ましい場合があります。

私はこのようにしたいと思います:)

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私の経験では、この方法で働くことは危険です。スタック全体でスローされたエラーはキャッチされます。このプロミスからのエラーだけではありません（これはおそらく望んでいるものではありません）。

promiseの2番目の引数は、すでに拒否/失敗のコールバックです。代わりにそれを使用するほうが安全です。

これを処理するために私が書いた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()
);