Jak obsługiwać flagę w wielu if-else

Wydaje mi się, że dość często to widzę w moim kodzie i innych. Nie ma w tym nic strasznie złego, ale denerwuje mnie, ponieważ wygląda na to, że można to zrobić lepiej. Przypuszczam, że instrukcja case może mieć trochę więcej sensu, ale często zmienna jest typem, który nie działa dobrze lub wcale z instrukcjami case (w zależności od języka)

If variable == A
    if (Flag == true)
        doFooA()
    else
        doFooA2

else if variable == B
    if (Flag == true)
        doFooB()
    else
        doFooB2
else if variable == C
    if (Flag == true)
        doFooC()
    else
        doFooC2

Wydaje się, że istnieje wiele sposobów na „uwzględnienie” tego, na przykład 2 zestawy if-elses, gdzie jeden zestaw obsługuje, gdy Flag == true.

Czy istnieje „dobry sposób” na uwzględnienie tego, a może kiedy ten algorytm się dzieje, zwykle oznacza to, że robisz coś źle?

Można sobie z tym poradzić z polimorfizmem.

factory(var, flag).doFoo();

Ilekroć masz kilka sprawdzeń typu if / else na typie czegoś, możesz rozważyć scentralizowanie sprawdzania if / else w metodzie fabrycznej, a następnie wywołać polimorficznie metodę doFoo (). Ale może to być nadmierne zabójstwo dla rozwiązania jednorazowego.

Może mógłbyś stworzyć mapę klucz / wartość, w której kluczem jest var / flag, a wartością jest sama funkcja.

do[var, flag]();

Wiele zagnieżdżonych ifs zwiększa cykliczną złożoność kodu. Do niedawna posiadanie wielu punktów wyjścia w funkcjach było uważane za źle skonstruowany kod, ale teraz, o ile kod jest prosty i krótki , możesz to zrobić, dzięki czemu kod jest trywialny:

    if (variable == A && Flag) {
        doFooA();
        return;
    }

    if (variable == A) {
        doFooA2();
        return;
    }

    if (variable == B && Flag){
        doFooB();
        return;
    }

    if (variable == B){
        doFooB2();
        return;
    }

    if (variable == C && Flag){
         doFooC();
         return;
    }

    if (variable == C){
         doFooC2();
    }

    return;

inną opcją jest połączenie if i przełączanie. Nie jest to lepsze niż technika zagnieżdżenia, ale może zmniejszyć liczbę zduplikowanych testów (jeśli przełącznik zoptymalizuje się do tabeli skoków).

if (flag)
{
    switch (variable)
    {
        case A:
           ... blah
           break;

        case B:
           ... blah
           break;

        case C:
           ... blah
           break;

        default:
           ... log an error.
           ... maybe do a default action.
           break;
    }
}
else // flag == false
{
    switch (variable)
    {
        case A:
           ... blah
           break;

        case B:
           ... blah
           break;

        case C:
           ... blah
           break;

        default:
           ... log an error.
           ... maybe do a default action.
           break;
}

Cóż, zawsze jest to ...

if variable == A && Flag
    doFooA()
else if variable == A 
    doFooA2    
else if variable == B && Flag
    doFooB()
else if variable == B
    doFooB2
else if variable == C && Flag
     doFooC()
else if variable == C
     doFooC2

Ale szczerze mówiąc, myślę, że oryginalny kod nie jest w połowie taki zły.

Użyj polimorfizmu i ruletablicy

interface IRule() {
  boolean applicable(args...);
  obj apply(args...);
}

static final Array<IRule> rules = [new MeaningfulNameRule1(), new MeaningfulNameRule2(), ...];

/* where */
class MeaningfulNameRuleX extends IRule{ /* */ }

/* In your method */

for (rule in rules) {
  if (rule.applicable(a,b,c)){
    return rule.apply(e,f,g);
  }
}

Lub zgodnie z mike30sugestią: jeśli warunki reguły mogą z łatwością utworzyć klucz, najlepszym rozwiązaniem jest hasztapa.