JavaScriptの約束-拒否とスロー

私はこの問題に関するいくつかの記事を読みましたがPromise.reject、エラーをスローすることとそれをスローすることの間に違いがあるかどうかはまだはっきりしません。例えば、

Promise.rejectの使用

return asyncIsPermitted()
    .then(function(result) {
        if (result === true) {
            return true;
        }
        else {
            return Promise.reject(new PermissionDenied());
        }
    });

スローを使用する

return asyncIsPermitted()
    .then(function(result) {
        if (result === true) {
            return true;
        }
        else {
            throw new PermissionDenied();
        }
    });

私の好みはthrow、それが短いからといって単純に使用することですが、一方が他方よりも優れているかどうか疑問に思っていました。

どちらか一方を使用する利点はありませんが、機能しthrowない特定のケースがあります。ただし、これらのケースは修正できます。

promiseコールバック内にいるときはいつでも、を使用できますthrow。ただし、他の非同期コールバックを使用してrejectいる場合は、を使用する必要があります。

たとえば、これはキャッチをトリガーしません：

new Promise(function() {
  setTimeout(function() {
    throw 'or nah';
    // return Promise.reject('or nah'); also won't work
  }, 1000);
}).catch(function(e) {
  console.log(e); // doesn't happen
});

代わりに、未解決の約束とキャッチされていない例外が残ります。代わりにを使用したい場合ですreject。ただし、これは2つの方法で修正できます。

1. タイムアウト内で元のPromiseの拒否機能を使用します。

new Promise(function(resolve, reject) {
  setTimeout(function() {
    reject('or nah');
  }, 1000);
}).catch(function(e) {
  console.log(e); // works!
});

2. タイムアウトを約束することにより：

function timeout(duration) { // Thanks joews
  return new Promise(function(resolve) {
    setTimeout(resolve, duration);
  });
}

timeout(1000).then(function() {
  throw 'worky!';
  // return Promise.reject('worky'); also works
}).catch(function(e) {
  console.log(e); // 'worky!'
});

もう一つの重要な事実はということですreject() DOESはしないように制御フローを終了するreturn文はありません。対照的に、throw制御フローは終了します。

例：

new Promise((resolve, reject) => {
  throw "err";
  console.log("NEVER REACHED");
})
.then(() => console.log("RESOLVED"))
.catch(() => console.log("REJECTED"));

対

new Promise((resolve, reject) => {
  reject(); // resolve() behaves similarly
  console.log("ALWAYS REACHED"); // "REJECTED" will print AFTER this
})
.then(() => console.log("RESOLVED"))
.catch(() => console.log("REJECTED"));

はい、最大の違いは、rejectはpromiseが拒否された後に実行されるコールバック関数ですが、throwは非同期で使用できないことです。rejectを使用することを選択した場合、コードは通常どおり非同期で実行されますが、throwはリゾルバー関数の完了を優先します（この関数はすぐに実行されます）。

私が問題を明確にするのを助けた私が見た例は、あなたが拒否でタイムアウト機能を設定することができたということでした、例えば：

new Promise(_, reject) {
 setTimeout(reject, 3000);
});

上記はスローで書くことはできませんでした。

あなたの小さな例では、区別がつかないほどの違いですが、より複雑な非同期の概念を扱う場合、2つの違いは劇的なものになる可能性があります。

TLDR： 関数がプロミスを返したり、例外をスローしたりする場合、関数は使いにくいです。非同期関数を作成するとき、拒否されたpromiseを返すことで失敗を通知することを好む

あなたの特定の例はそれらの間のいくつかの重要な違いを難読化しています：

あなたはプロミスチェーン内でエラー処理をしているため、スローされた例外は自動的に拒否されたプロミスに変換されます。これは、それらが交換可能であるように見える理由を説明するかもしれません-それらは交換可能ではありません。

以下の状況を考慮してください。

checkCredentials = () => {
    let idToken = localStorage.getItem('some token');
    if ( idToken ) {
      return fetch(`https://someValidateEndpoint`, {
        headers: {
          Authorization: `Bearer ${idToken}`
        }
      })
    } else {
      throw new Error('No Token Found In Local Storage')
    }
  }

これは、非同期と同期の両方のエラーケースをサポートする必要があるため、アンチパターンになります。次のようになります。

try {
  function onFulfilled() { ... do the rest of your logic }
  function onRejected() { // handle async failure - like network timeout }
  checkCredentials(x).then(onFulfilled, onRejected);
} catch (e) {
  // Error('No Token Found In Local Storage')
  // handle synchronous failure
} 

良くありません。ここPromise.reject（グローバルスコープで利用可能）が救いに出て、効果的に自分自身を区別する場所throwです。リファクタリングは次のようになります。

checkCredentials = () => {
  let idToken = localStorage.getItem('some_token');
  if (!idToken) {
    return Promise.reject('No Token Found In Local Storage')
  }
  return fetch(`https://someValidateEndpoint`, {
    headers: {
      Authorization: `Bearer ${idToken}`
    }
  })
}

これによりcatch()、ネットワーク障害とトークン不足の同期エラーチェックに1つだけ使用できるようになりました。

checkCredentials()
      .catch((error) => if ( error == 'No Token' ) {
      // do no token modal
      } else if ( error === 400 ) {
      // do not authorized modal. etc.
      }

試してみる例。isVersionThrowをfalseに変更して、スローではなく拒否を使用します。

const isVersionThrow = true

class TestClass {
  async testFunction () {
    if (isVersionThrow) {
      console.log('Throw version')
      throw new Error('Fail!')
    } else {
      console.log('Reject version')
      return new Promise((resolve, reject) => {
        reject(new Error('Fail!'))
      })
    }
  }
}

const test = async () => {
  const test = new TestClass()
  try {
    var response = await test.testFunction()
    return response 
  } catch (error) {
    console.log('ERROR RETURNED')
    throw error 
  }  
}

test()
.then(result => {
  console.log('result: ' + result)
})
.catch(error => {
  console.log('error: ' + error)
})