I remember having this argument with my professor at the school, who insisted that a function should have only one "return" clause at the very end. Even as I tried, I could not get him to explain why this would be valuable and how does this produce better code, so I'm interested on hearing your take on this?

▲

superxpro12 2 days ago | parent [-]

It helps prevent bugs with state. The apple login bypass bug comes to mind.

Basically, you have code in an "if" statement, and if you return early in that if statement, you might have code that you needed to run, but didnt.

Forcing devs to only "return once" encourages the dev to think through any stateful code that may be left in an intermediate state.

In practice, at my shop, we permit early returns for trivial things at the top of a function, otherwise only one return at the bottom. That seems to be the best of both worlds for this particular rule.

	▲	SideburnsOfDoom 2 days ago \| parent \| next [-]
		> The apple login bypass bug comes to mind. I think you're talking about this "goto fail" bug? https://teamscale.com/blog/en/news/blog/gotofail > In practice, at my shop, we permit early returns for trivial things Are you also writing C or similar? If so, then this rule is relevant. In modern languages, there are language constructs to aid the cleanup on exit, such as using(resource) {} or try {} finally {} It really does depend on if these conveniences are available or not. For the rest of us, the opposite of "no early return" is to choose early return only sometime - in cases where results in better code, e.g. shorter, less indented and unlikely to cause issues due to failure to cleanup on exit. And avoid it where it might be problematic. In other words, to taste. > Kent Beck, Martin Fowler, and co-authors have argued in their refactoring books that nested conditionals may be harder to understand than a certain type of flatter structure using multiple exits predicated by guard clauses. Their 2009 book flatly states that "one exit point is really not a useful rule. Clarity is the key principle: If the method is clearer with one exit point, use one exit point; otherwise don’t". https://en.wikipedia.org/wiki/Structured_programming#Early_e... this thinking is quite different to say, 25 years earlier than that, and IMHO the programming language constructs available play a big role.
	▲	Symmetry 2 days ago \| parent \| prev \| next [-]
		The rule of thumb I use is to only have one return after modifying state that will persist outside the function call.
	▲	mrgaro a day ago \| parent \| prev [-]
		Thank you!