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не вийде. Однак ці випадки можна виправити.

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

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() НЕ припиняє контрольний потік, як це 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"));

Так, найбільша різниця полягає в тому, що відхилення - це функція зворотного виклику, яка виконується після відхилення обіцянки, тоді як кидок не може використовуватися асинхронно. Якщо ви вирішили використовувати відхилити, ваш код буде продовжувати працювати нормально асинхронно, тоді як кидати визначає пріоритетність виконання функції розв’язувача (ця функція буде запущена негайно).

Я бачив приклад, який допомагав з’ясувати проблему для мене, це те, що ви можете встановити функцію Timeout з відхиленням, наприклад:

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

Вищезгадане неможливо було б написати з кидком.

У вашому невеликому прикладі різниця в нерозрізненні, але коли ми маємо справу зі складнішою асинхронною концепцією, різниця між ними може бути різкою.

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

Приклад спробувати. Просто змініть 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)
})