JavaScript Promises - отклонение против броска

Question

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

Answer 1

Нет преимущества использования одного и другого, но существует конкретный случай, когда throw не будет работать. Однако эти случаи могут быть исправлены.

Каждый раз, когда вы находитесь в обратном вызове с обещанием, вы можете использовать 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. Тем не менее, вы можете исправить это promisifying таймаут:

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

Answer 2

Да, большая разница в том, что отклонять является функцией обратного вызова, которая получает осуществляется после того, как обещание отвергается, в то время как броска не могут быть использованы асинхронно. Если вы решили использовать отклонение, ваш код будет продолжать нормально работать в асинхронном режиме, тогда как throw будет определять приоритетность завершения функции распознавателя (эта функция будет работать сразу).

пример я видел, что помогли прояснить этот вопрос для меня было то, что вы можете установить функцию тайм-аута с отвергаем, например:

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

выше не мог бы возможно написать с броском.

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

Answer 3

Другим важным фактом является то, что reject()НЕ прекращает управление потоком подобно 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"));

Answer 4

TLDR:Функция сложна в использовании, когда она иногда возвращает обещание и иногда выдает исключение. При написании функции асинхронной, предпочитает сигнал неисправности путем возврата отклоненного обещания

Ваш конкретный пример запутывает некоторые важные различия между ними:

Потому что вы регулируете ошибки внутри обещание цепь, брошенные исключения получают автоматически преобразован отклонил обещаний. Это может объяснить, почему они кажутся взаимозаменяемыми - это не так.

Рассмотрит ситуацию ниже:

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() для сетевых сбоев и синхронная проверка ошибок из-за отсутствия маркеров:

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

Answer 5

Пример попробовать. Просто измените isVersionThrow на false, чтобы использовать reject вместо throw.

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