Better way to express "if false return false" construct

Question

In many cases you have code like this (C-style pseudo code used):

bool checkCondition();

bool doSomething(){
   if (checkCondition() == false)
      return false;

   // do something
   return true;
}

I keep reusing this patter and every time wonder, if there is better way to express it?

Sometimes, the condition check can be left for the caller or asserted, but often condition check must be done inside the function.

You can get fancy and use exceptions, but result is almost the same code.

What do you mean by better? This is very simple and readable code ( ideal imo ). — George, May 09 '20 at 09:43
Some languages have `guard` statements that serve this purpose. The word `guard` expresses this feeling better than an `if` doesn't it? For example, in Swift you'd do `guard checkCondition() else { return false }`. But there is not such thing in Java. (don't know about C++). — Sweeper, May 09 '20 at 09:43
`if ( not condition()) return false;` but your solution is fine too — Martin Morterol, May 09 '20 at 09:44
@DominikWosiński Your statement does not allow for additional code inside the function. — sanitizedUser, May 09 '20 at 09:47
Yeah, I've removed the answer :) I didn't notice the do something :) — Dominik Wosiński, May 09 '20 at 10:22
You never, ever have to use "== false" or "== true" or "!= false" or "!= true" - the boolean instance itself has this information already. — Dave Doknjas, May 09 '20 at 13:29
@DaveDoknjas is more readable this way, at least for me. ! in front can not be always seen, "not" is considered lame. — Nick, May 09 '20 at 13:33
@Nick: For integer comparisons, do you write "i == 1 == false"? — Dave Doknjas, May 09 '20 at 16:27

Dorian Gray · Answer 1 · 2020-05-24T18:09:42.193

2

First I would express the negation like that:

 if (!checkCondition())
     return false;

Also I would prefer to have the positive condition in the if statement, whenever applicable (depending on the length of the blocks):

bool doSomething(){
      if (checkCondition()) {
         // do something
         return true;
      } else {
        return false;
     }
}

You could also drop the else here because of a return in the `if``statement.

bool doSomething(){
      if (checkCondition()) {
         // do something
         return true;
      }
      return false;
}

edited May 24 '20 at 18:09

answered May 09 '20 at 09:48

Dorian Gray

2,913
1
9
25

3

I think just simple `if (!condition) return false;` is better because you don't need any `else` and other brackets. – sanitizedUser May 09 '20 at 09:50
It depends on the length of the "do something" and on your personal taste. – Dorian Gray May 09 '20 at 09:53
2

@sanitizedUser it depends on how verbose you want to be. Personally I tend to agree with you but I'll usually just go with the flow of whatever codebase im working in. Anyway we're definitely in opinion territory. – George May 09 '20 at 09:54
I have added another variant here. I think, with the "Also I would prefer to..." introduction, I made it clear that we are in opinion territory here. A question like `if there is better way to express it?` can only have opinion based answers. It is too vague to get any hard facts, it merely asks for alternatives. – Dorian Gray May 24 '20 at 18:12

score 0 · Answer 2 · answered May 09 '20 at 09:51

Your code itself is simple and clean. But below is one more clean variation (avoiding explicit true/false)

bool doSomething(){
   var isConditionTrue = checkCondition();

   if (isConditionTrue) 
   {
       // if executes only in case of 'isConditionTrue = true'
       // do something
   }
   return isConditionTrue; 
}

score 0 · Answer 3 · answered May 09 '20 at 09:53

In most cases I prefer the following approach

bool doSomething()
{
    bool success = checkCondition();

    if ( success )
    {
        // do something
    }

    return success;
}

For example consider a function that appends a node to a singly-linked list in C.

struct Node
{
    int data;
    struct Node *next;
};

int append( struct Node **head, int data )
{
    struct Node *new_node = malloc( sizeof( struct Node ) );
    int success = new_node != NULL;

    if ( success )
    {
        new_node->data = data;
        new_node->next = NULL;

        while ( *head != NULL ) head = &( *head )->next;

        *head = new_node;        
    }

    return success;
}

score 0 · Answer 4 · answered May 24 '20 at 19:38

You can remove the if condition as below:

return checkCondition();

It is enough. This code is simple enough but if the checkCondition() function is not too large, you can define it as an "inline" function to enhance performance:

inline bool checkCondition() {//your code;}

Better way to express "if false return false" construct

4 Answers4