Нужно ли возвращаться после досрочного разрешения / отклонения?

Предположим, у меня есть следующий код.

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-, поскольку возвращаемое значение обратного вызова игнорируется, мы можем сохранить строку, вернув оператор reject / resol:

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не ожидает, что он что-либо возвратит, и ничего не делает с возвращаемым значением.

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

Это, как говорится, хорошая чистая практика, чтобы гарантировать, что точно один вызывается, когда это практически осуществимо, и, действительно, в этом случае, поскольку дальнейшая асинхронная / отложенная обработка не выполняется. Решение «вернуться рано» ничем не отличается от завершения любой функции, когда ее работа завершена, - против продолжения несвязанной или ненужной обработки.

Возврат в подходящее время (или иное использование условных выражений во избежание выполнения «другого» случая) снижает вероятность случайного запуска кода в недопустимом состоянии или выполнения нежелательных побочных эффектов; и как таковой он делает код менее подверженным неожиданному взлому.

¹ Это технически ответ зависит также от того , что в этом случае код после «возвращения», она должна быть опущена, не приведет к побочному эффекту. JavaScript с радостью разделится на ноль и вернет либо + Infinity / -Infinity, либо 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));