JavaScript Vaatleri - reddetme ve atma

Bu konuda birkaç makale okudum, ancak Promise.rejecthata atma ile hata atma arasında bir fark olup olmadığı hala net değil . Örneğin,

Promise.reject kullanma

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

Fırlatma kullanma

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

Benim tercihim throwsadece daha kısa olduğu için kullanmak , ancak birinin diğerine göre herhangi bir avantajı olup olmadığını merak ediyordu.

Birini diğerine karşı kullanmanın bir avantajı yoktur, ancak throwişe yaramayacağı özel bir durum vardır . Ancak, bu durumlar düzeltilebilir.

Ne zaman bir vaat geri arama içinde, kullanabilirsiniz throw. Ancak, başka bir eşzamansız geri arama yapıyorsanız, kullanmanız gerekir reject.

Örneğin, bu yakalamayı tetiklemez:

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

Bunun yerine, çözülmemiş bir vaat ve yakalanmamış bir istisna kaldı. Bu, bunun yerine kullanmak istediğiniz bir durumdur reject. Ancak, bunu iki şekilde düzeltebilirsiniz.

1. zaman aşımı içindeki orijinal Promise'ın reddetme işlevini kullanarak:

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

2. zaman aşımını vaat ederek:

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!'
});

Bir diğer önemli gerçektir ki reject() YAPAR DEĞİL bir benzeri kontrol akışını sonlandırmak returndeyimi yapar. Aksine throwkontrol akışını sonlandırır.

Misal:

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

vs

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

Evet, en büyük fark, reddetmenin , vaat reddedildikten sonra gerçekleştirilen bir geri arama işlevidir, oysa atış asenkron olarak kullanılamaz. Reddetmeyi seçerseniz, kodunuz eşzamansız olarak normal şekilde çalışmaya devam ederken, atma çözücü işlevini tamamlamaya öncelik verir (bu işlev hemen çalışır).

Sorunun benim için netleştirilmesine yardımcı olduğunu gördüğüm bir örnek, reddetme ile bir Zaman Aşımı işlevi ayarlayabileceğinizdi, örneğin:

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

Yukarıdakilerin fırlatmayla yazmak mümkün olamazdı.

Küçük örneğinizde ayırt edilemeyen fark, ancak daha karmaşık asenkron kavramla uğraşırken ikisi arasındaki fark büyük olabilir.

TLDR: Bir fonksiyon bazen bir söz verdiğinde ve bazen bir istisna attığında kullanmak zordur. Bir zaman uyumsuzluk işlevi yazarken, reddedilen bir vaat döndürerek hataya işaret etmeyi tercih edin

Özel örneğiniz, aralarındaki bazı önemli ayrımları gizler:

Bir söz zinciri içinde hata işlediğiniz için , atılan istisnalar otomatik olarak reddedilen sözlere dönüştürülür . Bu neden değiştirilebilir olduklarını açıklayabilir - değildir.

Aşağıdaki durumu düşünün:

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

Bu bir anti-desen olacaktır, çünkü daha sonra hem asenkron hem de senkronizasyon hata vakalarını desteklemeniz gerekir. Şuna benzeyebilir:

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
} 

İyi değil ve işte tam olarak Promise.reject(küresel kapsamda mevcut) kurtarmaya nereden geliyor ve kendini etkili bir şekilde farklı kılıyor throw. Refactor şimdi:

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

Bu artık catch()ağ arızaları ve jeton eksikliği için senkron hata kontrolü için sadece bir tane kullanmanızı sağlar :

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

Denemek için bir örnek. Atmak yerine reddetme işlevini kullanmak için isVersionThrow öğesini false olarak değiştirin.

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