Чи потрібно повернутися після раннього вирішення / відхилення?

Припустимо, у мене є такий код.

function divide(numerator, denominator) {
 return new Promise((resolve, reject) => {

  if(denominator === 0){
   reject("Cannot divide by 0");
   return; //superfluous?
  }

  resolve(numerator / denominator);

 });
}

Якщо моя мета полягає у використанні rejectдля виходу зранку, чи повинен я ввійти в звичку returnвідразу після цього?

returnМета полягає в тому, щоб припинити виконання функції після відмови, і запобігти виконанню коду після нього.

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {

    if (denominator === 0) {
      reject("Cannot divide by 0");
      return; // The function execution ends here 
    }

    resolve(numerator / denominator);
  });
}

У цьому випадку це запобігає resolve(numerator / denominator);виконанню, що вкрай не потрібно. Однак все-таки краще припинити виконання, щоб запобігти можливій пастці в майбутньому. Крім того, це непогана практика запобігання виконанню коду без потреби.

Фон

Обіцянка може бути в одному з 3 штатів:

1. очікуваний - початковий стан. З очікування ми можемо перейти до одного з інших штатів
2. виконано - успішна операція
3. відхилено - невдала операція

Коли обіцянка буде виконана або відхилена, вона залишатиметься в такому стані нескінченно (врегульовано). Отже, відхилення виконаної обіцянки або виконання відхиленої обіцянки не матиме ефекту.

Цей приклад прикладу показує, що хоча обіцянка була виконана після її відхилення, вона залишається відхиленою.

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      reject("Cannot divide by 0");
    }

    resolve(numerator / denominator);
  });
}

divide(5,0)
  .then((result) => console.log('result: ', result))
  .catch((error) => console.log('error: ', error));

То навіщо нам повертатися?

Хоча ми не можемо змінити встановлений стан обіцянки, відхилення або усунення не зупинить виконання решти функції. Функція може містити код, який створить заплутані результати. Наприклад:

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      reject("Cannot divide by 0");
    }
    
    console.log('operation succeeded');

    resolve(numerator / denominator);
  });
}

divide(5, 0)
  .then((result) => console.log('result: ', result))
  .catch((error) => console.log('error: ', error));

Навіть якщо функція не містить такого коду зараз, це створює можливу майбутню пастку. Майбутній рефактор може ігнорувати той факт, що код все ще виконується після відхилення обіцянки, і його буде важко налагодити.

Припинення виконання після вирішення / відхилення:

Це стандартний матеріал управління JS.

• Повернення після resolve/ reject:

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      reject("Cannot divide by 0");
      return;
    }

    console.log('operation succeeded');

    resolve(numerator / denominator);
  });
}

divide(5, 0)
  .then((result) => console.log('result: ', result))
  .catch((error) => console.log('error: ', error));

• Повернення з resolve/ reject- оскільки значення повернення зворотного дзвінка ігнорується, ми можемо зберегти рядок, повернувши заяву про відхилення / вирішення:

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      return reject("Cannot divide by 0");
    }

    console.log('operation succeeded');

    resolve(numerator / denominator);
  });
}

divide(5, 0)
  .then((result) => console.log('result: ', result))
  .catch((error) => console.log('error: ', error));

• Використання блоку if / else:

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) {
      reject("Cannot divide by 0");
    } else {
      console.log('operation succeeded');
      resolve(numerator / denominator);
    }
  });
}

divide(5, 0)
  .then((result) => console.log('result: ', result))
  .catch((error) => console.log('error: ', error));

Я вважаю за краще використовувати один із returnваріантів, так як код більш плащ.

Загальна ідіома, яка може бути, а може і не бути вашою чашкою чаю, полягає в поєднанні returnз тим reject, щоб одночасно відхилити обіцянку і вийти з функції, щоб решта функції, включаючи функцію resolve, не виконувалася. Якщо вам подобається цей стиль, він може зробити ваш код трохи більш компактним.

function divide(numerator, denominator) {
  return new Promise((resolve, reject) => {
    if (denominator === 0) return reject("Cannot divide by 0");
                           ^^^^^^^^^^^^^^
    resolve(numerator / denominator);
  });
}

Це чудово працює, оскільки конструктор Promise нічого не робить із поверненим значенням, а в будь-якому випадку resolveі rejectнічого не повертає.

Та сама ідіома може бути використана зі стилем зворотного дзвінка, показаним в іншій відповіді:

function divide(nom, denom, cb){
  if(denom === 0) return cb(Error("Cannot divide by zero"));
                  ^^^^^^^^^
  cb(null, nom / denom);
} 

Знову ж таки, це працює чудово, оскільки людина, яка телефонує divide, не сподівається, що вона поверне щось, і нічого не зробить зі значенням повернення.

Технічно це не потрібно ¹ - тому що Обіцянку можна вирішити або відхилена виключно і лише один раз. Перший результат Обіцянку виграє, і кожен наступний результат ігнорується. Це відрізняється від зворотних викликів у стилі Node.

Це, як кажуть, є хорошою чистою практикою щоб переконатися, що саме так називається, коли це практично, і справді в цьому випадку, оскільки немає ніякої подальшої асинхронізованої / відкладеної обробки. Рішення про "повернення достроково" не відрізняється від припинення будь-якої функції, коли її робота закінчена - проти продовження непов'язаної або непотрібної обробки.

Повернення у відповідний час (або використання інших умов для уникнення виконання "іншого" випадку) зменшує шанс випадкового запуску коду у недійсному стані або здійснення небажаних побічних ефектів; і як такий він робить код менш схильним до "несподіваного злому".

¹ Ця технічна відповідь також залежить від того, що в цьому випадку код після "повернення", якщо його буде опущено, не призведе до побічного ефекту. JavaScript буде радісно ділитися на нуль і повертатиме + Нескінченність / Нескінченність або NaN.

Якщо ви не повернетесь після вирішення / відхилення, погані речі (як перенаправлення сторінки) можуть статися після того, як ви мали намір зупинити її. Джерело: Я натрапив на це.

Відповідь Орі вже пояснює, що цього не потрібно, returnале це є хорошою практикою. Зауважте, що конструктор обіцянок є безпечним для кидання, тому він буде ігнорувати викинуті винятки, передані пізніше на шляху, фактично у вас є побічні ефекти, які ви не можете легко спостерігати.

Зауважте, що returnраннє використання також дуже часто зустрічається у зворотній зв'язок:

function divide(nom, denom, cb){
     if(denom === 0){
         cb(Error("Cannot divide by zero");
         return; // unlike with promises, missing the return here is a mistake
     }
     cb(null, nom / denom); // this will divide by zero. Since it's a callback.
} 

Тож, хоча це хороша практика у обіцянках, це вимагається із зворотними дзвінками. Деякі примітки щодо вашого коду:

• Ваш випадок використання гіпотетичний, насправді не використовуйте обіцянки з синхронними діями.
• Конструктор обіцянок ігнорує повернені значення. Деякі бібліотеки попереджають, якщо ви повернете неозначене значення, щоб застерегти вас від помилки повернення туди. Більшість не такі розумні.
• Конструктор обіцянок кидається в безпеку, він перетворює винятки у відхилення, але, як вказували інші - обіцянка вирішується один раз.

У багатьох випадках можливо перевірити параметри окремо і негайно повернути відхилену обіцянку за допомогою Promise.reject (причина) .

function divide2(numerator, denominator) {
  if (denominator === 0) {
    return Promise.reject("Cannot divide by 0");
  }
  
  return new Promise((resolve, reject) => {
    resolve(numerator / denominator);
  });
}


divide2(4, 0).then((result) => console.log(result), (error) => console.log(error));