Alternative to nested if for conditional logic

Question

Is there a design pattern or methodology or language that allows you to write complex conditional logic beyond just nested Ifs?

At the very least, does this kind of question or problem have a name? I was unable to find anything here or through Google that described what I was trying to solve that wasn't just, replace your IF with a Switch statement.

I'm playing around with a script to generate a bunch of data. As part of this, I'd like to add in a lot of branching conditional logic that should provide variety as well as block off certain combinations.

Something like, If User is part of group A, then they can't be part of group B, and if they have Attribute C, then that limits them to characteristic 5 or 6, but nothing below or above that.

I think you need to use a combination of switch statements and if statements. You can break your switch statements off into smaller helper functions that also have switch statements. — whs.bsmith, Jul 16 '17 at 04:17
@whs.bsmith I don't remember even one example (in almost 20 year of programming) where a `switch` statement simplified a nested `if`. But maybe I just got lucky ;) — Nir Alfasi, Jul 16 '17 at 04:26

Nir Alfasi · Accepted Answer · 2023-02-05T11:53:42.710

3

The answer is simple: refactoring.

Let's take an example (pseudo-code):

if (a) {
    if (b) {
        if (c) {
             // do something
        }
    }
}

can be replaced by:

if (a && b && c) {
    // do something
}

Now, say that a, b and c are complex predicates which makes the code hard to read, for example:

if (visitorIsInActiveTestCell(visitor) &&
    !specialOptOutConditionsApply(request, visitor) &&
    whatEverWeWantToCheckHere(bla, blabla)) {
    // do something
}

we can refactor it as well and create a new method:

def shouldDoSomething(request, visitor, bla, blabla) {
    return visitorIsInActiveTestCell(visitor) &&
        !specialOptOutConditionsApply(request, visitor) &&
        whatEverWeWantToCheckHere(bla, blabla)
}

and now our if condition isn't nested and becomes easier to read and understand:

if (shouldDoSomething(request, visitor, bla, blabla)) {
    // do something
}

Sometimes it's not straightforward to extract such logic and refactor, and it may require taking some time to think about it, but I haven't yet ran into an example in which it was impossible.

edited Feb 05 '23 at 11:53

answered Jul 16 '17 at 04:21

Nir Alfasi

53,191
11
86
129

This is useful for improving upon what I've started with today, and helped me reframe the problem. Essentially right now I have categorical data, and am trying to find ways to reduce the number of cases that need to be evaluated explicitly. Each parameter limits the number of options found in the next parameter, but with categorical data, each case must be evaluated to disprove it. I'm wondering, if I try to find a way to express it as a range, then I could potentially just not evaluate anything above/below a certain point in that. – ADataGMan Jul 16 '17 at 13:50
thats probably the most simplifying answer! – busssard Apr 01 '22 at 07:46
1

https://refactoring.guru/decompose-conditional can also be found here – busssard Apr 01 '22 at 09:27

score 2 · Answer 2 · answered Aug 29 '19 at 19:37

All of the foregoing answers seem to miss the question. One of the patterns that frequently occurs in hardware-interface looks like this:

if (something) {
  step1;
  if ( the result of step1) {
    step2;
     if (the result of step2) {
       step3;
     ... and so on
}}}...

This structure cannot be collapsed into a logical conjunction, as each step is dependent on the result of the previous one, and may itself have internal conditions.

In assembly code, it would be a simple matter of test and branch to a common target; i.e., the dreaded "go to". In C, you end up with a pile of indented code that after about 8 levels is very difficult to read.

About the best that I've been able to come up with is:

while( true) {
  if ( !something)
    break;
  step1
  if ( ! result of step1)
    break;
  step2
  if ( ! result of step2)
    break;
  step3
  ...
  break;
}

Does anyone have a better solution?

Looks like for your first example, you should consider a pipeline pattern, where actors work on the result of previous operations based on some condition and pass that result on to further actors. — Irwin, May 07 '20 at 20:52

score 0 · Answer 3 · answered Jul 16 '17 at 05:40

It is possible you want to replace your conditional logic with polymorphism, assuming you are using an object-oriented language.

That is, instead of:

class Bird:
    #...
    def getSpeed(self):
        if self.type == EUROPEAN:
            return self.getBaseSpeed();
        elif self.type == AFRICAN:
            return self.getBaseSpeed() - self.getLoadFactor() * self.numberOfCoconuts;
        elif self.type == NORWEGIAN_BLUE:
            return 0 if isNailed else self.getBaseSpeed(self.voltage)
        else:
            raise Exception("Should be unreachable")

You can say:

class Bird:
    #...
    def getSpeed(self):
        pass

class European(Bird):

    def getSpeed(self):
        return self.getBaseSpeed()


class African(Bird):

    def getSpeed(self):
        return self.getBaseSpeed() - self.getLoadFactor() * self.numberOfCoconuts


class NorwegianBlue(Bird):

    def getSpeed():
        return 0 if self.isNailed else self.getBaseSpeed(self.voltage)

# Somewhere in client code
speed = bird.getSpeed()

Taken from here.

Alternative to nested if for conditional logic

3 Answers3