我是否需要在早期解决/拒绝后返回？ [英] Do I need to return after early resolve/reject?

问题描述

假设我有以下代码。

  function divide（numerator，denominator）{
 return new Promise（ （解决，拒绝）=> {
 
如果（分母=== 0）{
拒绝（不能除以0）; 
返回; //多余？ 
} 
 
 resolve（分子/分母）; 
 
}）; 
} 
  

如果我的目标是使用拒绝提前退出，我是否应该立即养成返回的习惯？

解决方案

return 的目的是在拒绝后终止函数的执行，并阻止执行后的代码。

 功能除法（分子，分母）{
返回新的承诺（（解决，拒绝）=> {
 
 if（denominator === 0）{
 reject（不能除以0）; 
 return; //函数执行结束于此
} 
 
 resolve（分子/分母）; 
}）; 
} 
  

在这种情况下，它会阻止解析（分子/分母）; 来自执行，这不是严格需要的。但是，最好终止执行以防止将来出现可能的陷阱。此外，不必要地防止运行代码是一种很好的做法。

背景

承诺可以是以下三种状态之一：

1. 待定 - 初始状态。从待定状态我们可以移至其他状态


2. 履行 - 成功操作


3. 被拒绝 - 操作失败

当承诺履行或被拒绝时，它将无限期地（已结算）保持在此状态。因此，拒绝履行承诺或履行被拒绝的承诺将不起作用。

此示例代码段显示虽然承诺在被拒绝后已履行，但仍未被拒绝。

  function divide（numerator，denominator）{return new Promise（（resolve，拒绝）=> {if（分母=== 0）{reject（不能除以0）;} resolve（分子/分母）;}）;}除（5,0）.then（（result）= > console.log（'result：'，result））。catch（（error）=> console.log（'error：'，error））;  

那么为什么我们需要返回？

虽然我们无法更改已结算的承诺状态，但拒绝或解决不会停止执行其余功能。该函数可能包含会产生令人困惑的结果的代码。例如：

  function divide（numerator，denominator）{return new Promise（ （解决，拒绝）=> {if（denominator === 0）{reject（不能除以0）;} console.log（'operation succeeded'）; resolve（numerator / denominator）;}）;} divide（5,0）.then（（result）=> console.log（'result：'，result））。catch（（error）=> console.log（'error：'，error））;  

即使该函数现在不包含此类代码，创造一个可能的未来陷阱。未来的重构可能会忽略这样一个事实，即在承诺被拒绝后代码仍然执行，并且很难调试。

在解析后停止执行/拒绝：

这是标准的JS控制流程。

• 在解决后退货 / 拒绝：

  function divide（numerator，denominator）{return new Promise（（resolve，reject）= > {if（denominator === 0）{reject（不能除以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（不能除以0）; } console.log（'operation succeeded'）;解决（分子/分母）; }（）;除（5,0）.then（（result）=> console.log（'result：'，result））。catch（（error）=> console.log（'error：'，error ））;  

• 使用if / else block：

  function divide（numerator，denominator）{return new Promise（（resolve，reject）=> {if（denominator === 0）{reject（不能除以0）;} else {console.log（' operation succeeded'）; resolve（numerator / denominator）;}}）;} divide（5,0）.then（（result）=> console.log（'result：'，result））。catch（（error） => console.log（'错误：'，错误））;  

我更喜欢使用其中一个 return 选项，因为代码更平坦。

Suppose I have the following code.

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

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

  resolve(numerator / denominator);

 });
}

If my aim is to use reject to exit early, should I get into the habit of returning immediately afterward as well?

解决方案

The return purpose is to terminate the execution of the function after the rejection, and prevent the execution of the code after it.

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

In this case it prevents the resolve(numerator / denominator); from executing, which is not strictly needed. However, it's still preferable to terminate the execution to prevent a possible trap in the future. In addition, it's a good practice to prevent running code needlessly.

Background

A promise can be in one of 3 states:

1. pending - initial state. From pending we can move to one of the other states
2. fulfilled - successful operation
3. rejected - failed operation

When a promise is fulfilled or rejected, it will stay in this state indefinitely (settled). So, rejecting a fulfilled promise or fulfilling a rejected promise, will have not effect.

This example snippet shows that although the promise was fulfilled after being rejected, it stayed rejected.

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

So why do we need to return?

Although we can't change a settled promise state, rejecting or resolving won't stop the execution of the rest of the function. The function may contain code that will create confusing results. For example:

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

Even if the function doesn't contain such code right now, this creates a possible future trap. A future refactor might ignore the fact that the code is still executed after the promise is rejected, and will be hard to debug.

Stopping the execution after resolve/reject:

This is standard JS control flow stuff.

• Return after the 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));

• Return with the resolve / reject - since the return value of the callback is ignored, we can save a line by returning the reject/resolve statement:

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

• Using an if/else block:

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

I prefer to use one of the return options as the code is flatter.

这篇关于我是否需要在早期解决/拒绝后返回？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！