6

When i see code from others, i mainly see two types of method-styling.

One looks like this, having many nested ifs:

void doSomething(Thing thing) {
  if (thing.hasOwner()) {
    Entity owner = thing.getOwner();
    if (owner instanceof Human) {
      Human humanOwner = (Human) owner;
      if (humanOwner.getAge() > 20) {
        //...
      }
    }
  }
}

And the other style, looks like this:

void doSomething(Thing thing) {
  if (!thing.hasOwner()) {
    return;
  }
  Entity owner = thing.getOwner();
  if (!(owner instanceof Human)) {
    return;
  }
  Human humanOwner = (Human) owner;
  if (humanOwner.getAge() <= 20) {
    return;
  }
  //...
}

My question is, are there names for these two code styles? And if, what are they called.

0xLuca
  • 155
  • 1
  • 7
  • I don’t know of a name, but the difference has been noted before. There was (is?) a classic aversion against having multiple return statements in a method (and some languages did not allow it). I don’t personally see any problem with either style, so I agree with your description, it is a matter of — style, exactly. – Ole V.V. Jan 21 '21 at 06:19

4 Answers4

7

The early-returns in the second example are known as guard clauses.

Prior to the actual thing the method is going to do, some preconditions are checked, and if they fail, the method immediately returns. It is a kind of fail-fast mechanism.

There's a lot of debate around those return statements. Some think that it's bad to have multiple return statements within a method. Others think that it avoids wrapping your code in a bunch of if statements, like in the first example.

My own humble option is in line with this post: minimize the number of returns, but use them if they enhance readability.

Related:

MC Emperor
  • 22,334
  • 15
  • 80
  • 130
  • 1
    More liinks: (1) [Guard (computer science)](https://en.wikipedia.org/wiki/Guard_(computer_science)) (2) [Refactoring: Guard Clauses](https://medium.com/better-programming/refactoring-guard-clauses-2ceeaa1a9da) – Ole V.V. Jan 21 '21 at 06:52
3

I don't know if there is a recognized name for the two styles, but in structured programming terms, they can be described as "single exit" versus "multiple exit" control structures. (This also includes continue and break statements in loop constructs.)

The classical structured programming paradigm advocated single exit over multiple exit, but most programmers these days are happy with either style, depending on the context. Even classically, relaxation of the "single exit" rule was acceptable when the resulting code was more readable.

(One needs to remember that structured programming was a viewed as the antidote to "spaghetti" programming, particularly in assembly language, where the sole control constructs were conditional and non-conditional branches.)

Stephen C
  • 698,415
  • 94
  • 811
  • 1,216
2

i would say it's about readability. The 2nd style which i prefer, gives you the opportunity to send for example messages to the user/program for any check that should stop the program.

Melron
  • 569
  • 4
  • 10
2

One could call it "multiple returns" and "single return". But I wouldn't call it a style, you may want to use both approaches, depending on readability in any particular case.

Single return is considered a better practice in general, since it allows you to write more readable code with the least surprise for the reader. In a complex method, it may be quite complicated to understand at which point the program will exit for any particular arguments, and what side effects may occur.

But if in any particular case you feel multiple returns improve readability of your code, there's nothing wrong with using them.

Forketyfork
  • 7,416
  • 1
  • 26
  • 33
  • *"Single return is considered a better practice in general"* - considered by who? It's the recommendation of the old-school "structured programming" proponents, but there is actually research showing people find the multiple-return style easier to understand. It makes sense when you consider that a lot of algorithms otherwise have to use additional boolean flags indicating whether the algorithm should have returned yet. – kaya3 Jan 21 '21 at 06:27
  • @kaya3 I think you've answered your own question. I would say it depends on the particular case. Procedural algorithms are a special, and, frankly, quite a narrow corner case, compared to application programming. – Forketyfork Jan 21 '21 at 06:32
  • Personally i prefer the seconds style, mostly because i want to get rid of all the cases i dont need to handle in my logical code, and readability. I think, its easier to read the code if it does not go a tab-space to the right everytime i need to check something which wouldn't be logically handled anyways. – 0xLuca Jan 21 '21 at 06:35
  • @Sergei What I mean is that what "structured programming" proponents consider good practice is not the same as what is "generally" considered good practice. To be clear, I mean "algorithm" in the widest possible sense. – kaya3 Jan 21 '21 at 07:32