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

Цель 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);, что не является строго необходимым. Однако все же предпочтительнее прекратить выполнение, чтобы предотвратить возможную ловушку в будущем. Кроме того, рекомендуется предотвращать ненужный запуск кода.

Фон

Обещание может находиться в одном из трех состояний:

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 / resolve:

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 может быть разрешен или отклонен, исключительно и только один раз. Побеждает первый результат Promise, а все последующие результаты игнорируются. Это отличается от обратных вызовов в стиле узла.

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

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

¹ Этот технически ответ также зависит от того факта, что в данном случае код после "возврата", если он будет опущен, не приведет к в побочном эффекте. JavaScript с радостью разделит на ноль и вернет либо + Infinity / -Infinity, либо NaN.

Ответ Ори уже объясняет, что return не обязательно, но это хорошая практика. Обратите внимание, что конструктор обещаний является безопасным, поэтому он будет игнорировать выброшенные исключения, переданные позже в пути, по сути, у вас есть побочные эффекты, которые вы не можете легко заметить.

Обратите внимание, что раннее returning также очень часто используется в обратных вызовах:

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

Итак, хотя это хорошая практика в обещаниях, это требуется с обратными вызовами. Некоторые примечания к вашему коду:

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

Во многих случаях можно проверить параметры отдельно и немедленно вернуть отклоненное обещание с помощью 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));