Question

如果我们具有相同的条件但标准不同，则切换case语句可以替换嵌套的if语句。但是，如果那些嵌套的if语句都具有不同且独特的条件，那么什么是好的方法呢？我是否有任何替代选项来替换彼此嵌套的十几个if else语句？

示例代码：

注意：我知道这是非常难以理解的 - 这就是重点。
注意：所有条件都是唯一的。

...

if (condition) {
    // do A
} else {                       
    if (condition) {
        // do B
    if (condition) {
        if (condition) {
            if (condition) {
                // do C
                if (condition) {
                    // do D
                    if (condition) {
                        // do E
                    } else {                                                   
                        if (condition) {
                            // do F
                        }
                    }
                }
            }

            if (condition) {
                // do G
                if (condition) {
                    // do H
                    if (condition) {
                        // do I
                    } else {
                        // do J
                    }
                }
            }
        }
    }
}

Answer 1

在我看来，存在两种消除嵌套条件的主要方法。当我们在每个嵌套条件中只有一个条件时，第一个用于更特殊的情况：

function A(){
    if (condition1){
        if (condition2){
            if (condition3){
                // do something
            }
        }
    }
}

我们可以从相反的条件退出：

function A(){
    if (condition1 == false) return;
    if (condition2 == false) return;
    if (condition3 == false) return;  
    // do something 
}

第二个是使用条件分解，可以被视为比第一个更普遍。在我们有这样的条件结构的情况下，例如：

if (condition1)  
{
    // do this 1
}
else 
{                                                   
    if (condition2) 
    {
        // do this 2
    }                                                    
}

我们可以为每个特定条件实现变量，如下所示：

bool Cond1 = condition1;
bool Cond2 = !condition1 && condition2;

if (Cond1) { //do this 1 }
if (Cond2) { //do this 2 }

Answer 2

@Tar提出了一种看待它的方法。另一个可能是。

反转它。

if (myObject.HasThing1)
{
   if(myObject.HasThing2)
   {
      DoThing1();
   }
   else
   {
      DoThing2();
   }
}
else
{
   DoThing3();
}

可能是

DoThing1(myObject.HasThing1);
DoThing2(myObject.HasThing2);
DoThing3(myObject.HasThing3);

因此每个Do方法都会产生最小数量的测试，如果有任何失败，它就不会做任何事情。

如果你想以几种方式突破序列，你可以让它更聪明。

不知道它是否适合你，但委托测试条件通常足以成为一种新的看待事物的方式，一些简化因素可能看起来就好像魔术一样。

Answer 3

当我看到代码时，我必须检查这是Stackoverflow而不是DailyWTF！

解决方案是更改体系结构并使用接口和多态来绕过所有条件。然而，这可能是一项巨大的工作，超出了可接受答案的范围，所以我会建议另一种方法，你可以使用具有独特条件的Switch语句：

[Flags]
public enum FilterFlagEnum
{
    None = 0,
    Condition1 = 1,
    Condition2 = 2,
    Condition3 = 4,
    Condition4 = 8, 
    Condition5 = 16,
    Condition6 = 32,
    Condition7 = 64 
}; 


public void foo(FilterFlagEnum filterFlags = 0)
{
        if ((filterFlags & FilterFlagEnum.Condition1) == FilterFlagEnum.Condition1)
        {
            //do this
        }
        if ((filterFlags & FilterFlagEnum.Condition2) == FilterFlagEnum.Condition2)
        {
            //do this
        }
}


foo(FilterFlagEnum.Condition1 | FilterFlagEnum.Condition2);

Answer 4

如果这确实是业务逻辑，那么语法就可以了。但我从未见过复杂的业务逻辑。绘制流程图，看看是否无法简化。

if (condition)  
{
    // do this
}
else 
{                                                   
    if (condition) 
    {
        // do this
    }                                                    
}

可以替换为

if (condition)  
{
    // do this
}
else if (condition) 
{
    // do this                                                    
}

但是再次退后一步并审查设计。如果清理，需要的不仅仅是其他。

Answer 5

我感到痛苦。

我的情况需要编写许多（> 2000）功能测试，这些测试是客户为大型昂贵的设备指定的。虽然大多数（> 95％）的这些测试都很简单并且有直接的通过/失败检查，但是在与您相似或更差的深度处，有数十个属于“多个嵌套，如果这样做会做出不同的事情”。

我提出的解决方案是在我的测试应用程序中托管Windows Workflow。

所有复杂的测试都变成了我运行的工作流程，并将结果报告回我的测试应用程序。

客户很高兴，因为他们有能力：

验证测试逻辑（对于非深深嵌套的非程序员来说很困难if / else C＃ - 很容易查看图形流程图）
以图形方式编辑测试
添加新测试

托管Windows Workflow（在.NET 4 / 4.5中）非常简单 - 尽管可能需要一段时间才能了解工作流与代码之间的“通信” - 主要是因为有多种方法可以实现。

祝你好运

替换If Else唯一条件嵌套语句

5 个答案: