How to code these conditional statements in more elegant & scalable manner

问题

In my software, I need to decide the version of a feature based on 2 parameters. Eg.

Render version 1 -> if (param1 && param2) == true;
Render version 2 -> if (!param1 && !param2) == true;
Render version 3 -> if only param1 == true;
Render version 4 -> if only param2 == true;

So, to meet this requirement, I wrote a code which looks like this -

if(param1 && param2) //both are true {
    version = 1;
}
else if(!param1 && !param2) //both are false {
    version = 2;
}
else if(!param2) //Means param1 is true {
    version = 3;
}
else { //Means param2 is true
    version = 4;
}

There are definitely multiple ways to code this but I finalised this approach after trying out different approaches because this is the most readable code I could come up with.
But this piece of code is definitely not scalable because -

1. Let say tomorrow we want to introduce new param called param3. Then the no. of checks will increase because of multiple possible combinations.
   
2. For this software, I am pretty much sure that we will have to accommodate new parameters in future.

Can there be any scalable & readable way to code these requirements?

回答1:

EDIT: For a scalable solution define the versions for each parameter combination through a Map:

Map<List<Boolean>, Integer> paramsToVersion = Map.of(
        List.of(true, true), 1,
        List.of(false, false), 2,
        List.of(true, false), 3,
        List.of(false, true), 4);

Now finding the right version is a simple map lookup:

    version = paramsToVersion.get(List.of(param1, param2));

The way I initialized the map works since Java 9. In older Java versions it’s a little more wordy, but probably still worth doing. Even in Java 9 you need to use Map.ofEntries if you have 4 or more parameters (for 16 combinations), which is a little more wordy too.

Original answer: My taste would be for nested if/else statements and only testing each parameter once:

    if (param1) {
        if (param2) {
            version = 1;
        } else {
            version = 3;
        }
    } else {
        if (param2) {
            version = 4;
        } else {
            version = 2;
        }
    }

But it scales poorly to many parameters.

回答2:

If you have to enumerate all the possible combinations of Booleans, it's often simplest to convert them into a number:

//                            param1:   F  T  F  T
//                            param2;   F  F  T  T
static final int[] VERSIONS = new int[]{2, 3, 4, 1};

...
version = VERSIONS[(param1 ? 1:0) + (param2 ? 2:0)];

回答3:

I doubt that there is a way that would be more compact, readable and scalable at the same time.

You express the conditions as minimized expressions, which are compact and may have meaning (in particular, the irrelevant variables don't clutter them). But there is no systematism that you could exploit.

A quite systematic alternative could be truth tables, i.e. the explicit expansion of all combinations and the associated truth value (or version number), which can be very efficient in terms of running-time. But these have a size exponential in the number of variables and are not especially readable.

I am afraid there is no free lunch. Your current solution is excellent.

---

If you are after efficiency (i.e. avoiding the need to evaluate all expressions sequentially), then you can think of the truth table approach, but in the following way:

• declare an array of version numbers, with 2^n entries;

• use the code just like you wrote to initialize all table entries; to achieve that, enumerate all integers in [0, 2^n) and use their binary representation;

• now for a query, form an integer index from the n input booleans and lookup the array.

Using the answer by Olevv, the table would be [2, 4, 3, 1]. A lookup would be like (false, true) => T[01b] = 4.

What matters is that the original set of expressions is still there in the code, for human reading. You can use it in an initialization function that will fill the array at run-time, and you can also use it to hard-code the table (and leave the code in comments; even better, leave the code that generates the hard-coded table).

回答4:

Your combinations of parameters is nothing more than a binary number (like 01100) where the 0 indicates a false and the 1 a true.

So your version can be easily calculated by using all the combinations of ones and zeroes. Possible combinations with 2 input parameters are:

1. 11 -> both are true
2. 10 -> first is true, second is false
3. 01 -> first is false, second is true
4. 00 -> both are false

So with this knowledge I've come up with a quite scalable solution using a "bit mask" (nothing more than a number) and "bit operations":

public static int getVersion(boolean... params) {
    int length = params.length;
    int mask = (1 << length) - 1;
    for(int i = 0; i < length; i++) {
        if(!params[i]) {
            mask &= ~(1 << length - i - 1);
        }
    }
    return mask + 1;
}

The most interesting line is probably this:

mask &= ~(1 << length - i - 1);

It does many things at once, I split it up. The part length - i - 1 calculates the position of the "bit" inside the bit mask from the right (0 based, like in arrays).

The next part: 1 << (length - i - 1) shifts the number 1 the amount of positions to the left. So lets say we have a position of 3, then the result of the operation 1 << 2 (2 is the third position) would be a binary number of the value 100.

The ~ sign is a binary inverse, so all the bits are inverted, all 0 are turned to 1 and all 1 are turned to 0. With the previous example the inverse of 100 would be 011.

The last part: mask &= n is the same as mask = mask & n where n is the previously computed value 011. This is nothing more than a binary AND, so all the same bits which are in mask and in n are kept, where as all others are discarded.

All in all, does this single line nothing more than remove the "bit" at a given position of the mask if the input parameter is false.

---

If the version numbers are not sequential from 1 to 4 then a version lookup table, like this one may help you.

The whole code would need just a single adjustment in the last line:

return VERSIONS[mask];

Where your VERSIONS array consists of all the versions in order, but reversed. (index 0 of VERSIONS is where both parameters are false)

回答5:

I would have just gone with:

if (param1) {
    if (param2) {
    } else {
    }
} else {
    if (param2) {
    } else {
    }
}

Kind of repetitive, but each condition is evaluated only once, and you can easily find the code that executes for any particular combination. Adding a 3rd parameter will, of course, double the code. But if there are any invalid combinations, you can leave those out which shortens the code. Or, if you want to throw an exception for them, it becomes fairly easy to see which combination you have missed. When the IF's become too long, you can bring the actual code out in methods:

if (param1) {
    if (param2) {
        method_12();
    } else {
        method_1();
    }
} else {
    if (param2) {
        method_2();
    } else {
        method_none();
    }
}

Thus your whole switching logic takes up a function of itself and the actual code for any combination is in another method. When you need to work with the code for a particular combination, you just look up the appropriate method. The big IF maze is then rarely looked at, and when it is, it contains only the IFs themselves and nothing else potentially distracting.

来源：https://stackoverflow.com/questions/54723382/how-to-code-these-conditional-statements-in-more-elegant-scalable-manner