最佳做法-多个退货声明

Question

I've seen a similar question, but I wanted some additional clarity on when people feel it is not OK to use multiple return statements. (I believe this is a language agnostic question)

I've always tried really hard to make sure there is always just one exit statement for a method.

Example:

doSomething: function() {
  for (var i = 0; i < 10; i++) {
    if (objCars[i].color == "red") {
      this.carIndex = i;
      return true;
    }
  }
  return false;
}

Previously I would have re-written something like this:

doSomething: function() {
  var bResult = false;
  for (var i = 0; i < 10; i++) {
    if (objCars[i].color == "red") {
      this.carIndex = i;
      bResult = true;
      break;
    }
  }

  return bResult;
}

Now I know there are cases where I might skip over the whole function/method entirely by putting a check and return right at the beginning.. but in cases like this.. is it better to stick to the single exit statement, or does it really not improve the readability of the code even in this scenario?

Thanks, -Stephen

Answer 1

In that particular example, the first option is more efficient because it exits the loop the first time it finds a red car. I personally prefer a single return per function, especially if it's a long method.

For this case, I would have done this:

doSomething: function() {
  var i = 0;
  while (i < 10 && objCars[i].color != "red") {
    this.carIndex = i;  
    i++
  }  
  return i < 10;  
}

Hope it helps

Answer 2

I find the single return statement a lot clearer in this case.

You know right away that, because the function returns within the if block, it will only give out a single value. At a glance, it is hard to tell in the second example if the function is building a list of values to return or not. This is specially true in untyped languages.

You also have an increase in performance as you prevent your code from looping as soon as you find a valid value. In the first example, you might run through the for loop for a single iteration, while the single one will always run for all 10 iterations. You could prevent this by changing the loop's condition, but this makes the code even more convulsed by accessing a variable in many unrelated places.

On an historical note, the reason why a lot of people insist on single return statement is to help with debugging. Since the function only has one exit point, it is easy to add a breakpoint there to see the returned result. This is greatly mitigated in modern debuggers with the ability to see the return value of functions as well as simply storing the return value inside a variable before using it when calling the function.