7

Duplicate: Should a function have only one return statement?

Often times you might have a method that checks numerous conditions and returns a status (lets say boolean for now). Is it better to define a flag, set it during the method, and return it at the end :

boolean validate(DomainObject o) {
  boolean valid = false;
  if (o.property == x) {
     valid = true;
  } else if (o.property2 == y) {
     valid = true;
  } ...
  return valid; 
}

or is it better/more correct to simply return once you know the method's outcome?

boolean validate(DomainObject o) {

  if (o.property == x) {
     return true;
  } else if (o.property2 == y) {
     return true;
  } ...
  return false; 
}

Now obviously there could be try/catch blocks and all other kinds of conditions, but I think the concept is clear. Opinions?

Community
  • 1
  • 1
Gandalf
  • 9,648
  • 8
  • 53
  • 88
  • Only one property has to be valid for the whole thing to be valid? – Michael Myers May 19 '09 at 18:58
  • duplicate http://stackoverflow.com/questions/36707/should-a-function-have-only-one-return-statement – z - May 19 '09 at 18:59
  • another link http://stackoverflow.com/questions/124122/single-return-or-multiple-return-statements-closed – z - May 19 '09 at 19:00
  • It's just a simple example. There could be an number of combinations of valid properties. But do you return from inside the condition statements or set a flag variable and only return at the end of the method, that's the real question. – Gandalf May 19 '09 at 19:07
  • I agree it's a duplicate - but the closing of questions is a bit overkill unless for some reason they are a detriment to the community. Having new debates on an older topic seems well within bounds for a site like this. And the debate will not move over to an old thread. Neither of the above threads showed up in the "possible duplicate question" list when I entered this question. – Gandalf May 19 '09 at 19:12

10 Answers10

12

If it's a method you'll be calling thousands of times, then early return is better to achieve a [slightly] increased performance.

If not, then I'd prefer late return, since it improves readability.

Remember programmers usually spend more time reading than writing code, so anything you can do to improve readability will be certainly welcome.

Seb
  • 24,920
  • 5
  • 67
  • 85
  • 42
    How is late return more readable? To me it's convoluted to return late. I infer from it that the method isn't done doing what it needs to if it hasn't returned. – Ben S May 19 '09 at 19:00
  • 1
    It's more readable because you don't cut the process flow in the middle of it. Instead, you save the state and return at the end of the method. – Seb May 19 '09 at 19:03
  • 9
    I find the flag way less readable precisely because you have to follow exactly each condition, method call, etc. to know if someone else touched the flag before returning, whereas with the other alternative you are certain that when property is equal to x you will get true, no matter what else happens there. – Vinko Vrsalovic May 19 '09 at 19:05
  • 5
    It's pretty clear that guard code is a good place to put an early return in Java. You aren't "cutting the process flow in the middle" because the process hasn't started and you avoid wrapping the body of the method in an if block. Of course it is sometimes appropriate to throw an exception after guard code. Multiple nested blocks are the enemy of readability not early returns (but if you have multiple nested blocks early returns can make it worse). – Matt Aug 07 '12 at 13:57
12

I prefer returning early and avoiding deep nesting. This is particularly true right at the start of the method: test anything that's simple, and get out (or throw an exception) if you can do so really early.

If it's right in the middle of a method, it's more of a judgement call.

Note that I'd refactor your example straight away to use a single if:

boolean validate(DomainObject o) {    
  if (o.property == x || o.property2 == y) {
     return true;
  } ...
  return false; 
}

I realise this was only a toy example, but my point is that it's always worth looking for more ways to simplify your code :)

Jon Skeet
  • 1,421,763
  • 867
  • 9,128
  • 9,194
6

As with most coding styles, it's really a matter of preference, but guard clauses are considered by many to be a best practice.

Bill the Lizard
  • 398,270
  • 210
  • 566
  • 880
  • This is not a matter of guard clause; it's a matter of returning different values depending on parameters. Nobody talked about parameters being right or wrong, or the need of having preconditions. – Seb May 19 '09 at 19:01
  • @Seb: Guard clauses are similar to, not the same as, preconditions. Guard clauses aren't restricted to parameter validation, either. You can use a guard clause to quickly return in trivial cases, resulting in multiple return points, which is what the question is about. – Bill the Lizard May 20 '09 at 13:33
4

The only time I would say you definitely shouldn't return early is if you can't easily see every return within a single screen (whatever the standard might be for people working on the same code base), you should at the very least be adding comments indicating that the function can return early if there is an early return.

The only time I would say you definitely should return early is if your code looks like...

boolean valid = true;
if( condition1 ) {
   valid = false;
}
if( valid ) {
   ...
   if( condition2 ) {
      valid = false;
   }
}
if( valid ) {
   ...
   if( condition3 ) {
      valid = false;
   }
}
... (etc)

If you find yourself in either of these situations, however... you should probably be refactoring the function.

Illandril
  • 656
  • 4
  • 11
  • +1 for your last line; you should indeed be pulling out smaller methods if the function gets to be too long. – Hace Sep 06 '10 at 07:44
2

To me, this is sort of one of those religious war topics with no correct answer. The argument against returning early essentially boils down to the fact that having one and only one point where a function can exit reduces the number of possible paths through your code, thus, in theory at least, reducing the chances for bugs. My personal style is to, in situations where it makes sense to return early do so, and in situations where it makes sense to limit to one return statement I do that.

shsteimer
  • 28,436
  • 30
  • 79
  • 95
2

There are two factors pulling against each other.

The first factor is ease of debugging. If you return immediately (as shown in your second code snippet), it sometimes becomes difficult to debug a big function since it is hard to find these return statements, specially if they were put there by mistake.

The second factor is ease of implementation. If you are checking basic correctness of arguments at the beginning of the function and there is a long piece of code before the function finishes, you might have to put that entire code in a condition loop. If you don't, at some point the argument might get used for some long calculation, wasting time, because it would ultimately be rejected anyways.

So, the answer could be like this:

If the function is small, 
        save the return status in a variable and return at the end. 
else 
        return immediately.
euphoria83
  • 14,768
  • 17
  • 63
  • 73
1

If exceptions aren't part of the picture, I prefer returning immediately when I can.

It can be easy to mismanage the flag variable and I'm against flag variables in general. Not returning also might make a maintainer think that further work might be done (if the method is long).

Ben S
  • 68,394
  • 30
  • 171
  • 212
0

Personally, I like the second method better. It is straightforward and clearer to me, but I do know there are people who must have only one return in a function.

CookieOfFortune
  • 13,836
  • 8
  • 42
  • 58
0

Honestly I think it depends on the situation. Personally I use both, and I decide based on which one will make the code more clear and easy to read.

If you have heavily nested if statements (or any other control structure) and it may get confusing, then I would return inside the statements

Don't worry too much about what is 'best practice' in this case, as it is more important that the code is clear and easy to understand. Use what feels right for the situation.

Tom Neyland
  • 6,860
  • 2
  • 36
  • 52
0

For this case, I prefer:

boolean validate (DomainObject o) {
    if (o.property == x ||
        o.property2 == y ||
        ...) {
          return true;
    } else {
          return false;
}

In general, I like to use early return to handle error conditions, and return at the end to return computed results.

user49117
  • 786
  • 3
  • 9