Approaches for checking multiple conditions? [duplicate]

Question

What is the best practice for checking multiple conditions, in no particular order?

The example in question needs to check four distinct conditions, in any order, and fail showing the correct error message.

The examples below use a C-like syntax.

Option 1: Check all at once

This method isn't preferred because the reasons why the condition failed aren't easy to discern.

if (A && B && C && D) {
    // continue here...
} else {
    return "A, B, C, or D failed";
}

Option 2: Nested Conditions

In the past, I used to use nested conditional statements, like so. This can get really confusing.

if (A) {
    if (B) {
        if (C) {
            if (D) {
                // continue here...
            } else {
                return "D failed"
            }
        } else {
            return "C failed";
        }
    } else {
        return "B failed";
    }
} else {
    return "A failed";
}

Option 3: Fail-early

This is the current method I use, which I like to call fail-early. As soon as a "bad" condition is hit, it returns.

if (!A) {
    return "A failed";
}

if (!B) {
    return "B failed";
}

if (!B) {
    return "C failed";
}

if (!D) {
    return "D failed";
}

// continue here...

Option 4: Collect Errors

One last approach I can think of is a sort of collection of errors. If the conditions to test for are completely separate, one might want to use this approach.

String errors = "";
if (!A) {
     errors += "A failed\n";
}

if (!B) {
    errors += "B failed\n";
}

if (!C) {
    errors += "C failed\n";
}

if (!D) {
    errors += "D failed\n";
}

if (errors.isEmpty()) {
    // continue here...
} else {
    return errors;
}

What are the best practices for checking multiple conditions? In terms of expectations, it ideally behaves like example 4, where details of all the failures are returned.

Answer 1

The answer is... it depends.

Does any one of A, B, C, or D cause it not to work? Does checking for A and failing make checking for B, C, or D impractical or redundant? Is it useful to report the collection of errors that were reported or just the first one detected?

Each of the options presented has its use in the proper situation. There is no one error handling approach to rule them all.

Answer 2

It really depends on what kind of information you want back from the function. Let's break down what every option gives you :

1. You don't care which condition fails, you only want to know if they all succeed or not.

2. Clearly out of the way. Very bad formatting and readability because of code nesting. Does the same thing as #3 but uglier.

3. You get to know the first condition that failed.

4. You get to know every condition that failed.

Now it's really up to you to judge which option is the best, depending on the context and what information you really need.

Answer 3

The answer depends hugely on what language you're using and what you are going to do as a consequence of the errors.

For example, in Scala, and assuming that I want to report every error so that they can all be fixed at once, I'd probably do something like

val (yes, no) = List(
  (A, "A failed"),
  (B, "B failed"),
  (C, "C failed"),
  (D, "D failed")
).partition(_._1)
if (!no.isEmpty) Some(no.map(_._2)) else None

where I first group my conditions and error messages, then sort them into two groups--the successes and the failures--and return those error messages if there was something, and otherwise return a sentinel value saying--in this case--that everything's okay.

But this relies critically on Scala's ability to quickly group and map and manipulate collections and containers. In Java, I would write the exact same code in the more verbose (and less convenient to check, as I now need to query errors.size() to know whether I have failed anything):

ArrayList<String> errors = new ArrayList<String>();
if (!A) errors.add("A failed");
if (!B) errors.add("B failed");
if (!C) errors.add("C failed");
if (!D) errors.add("D failed");
return errors;

If we only need the first error, in Java I'd do fail-fast while in Scala I might

List(A,B,C,D).zipWithIndex.find(!_._1).foreach{ x => return x._2 }

assuming I was okay with the number of the item that went bad as a return code.

So the answer is really: you've got the important different styles, but how exactly to implement them most efficiently/least painfully is going to depend a lot on your tools.