9

例如...

if ( /* Condition */ ) {

    if ( /* Condition */ ) {

        if ( /* Condition */ ) {

          // Superb!

        } else {

          // Error 3

        }

    } else {

      // Error 2

    }

} else {

  // Error 1

}

你知道如何避免这种情况吗？谢谢！

4

8 回答 8

11

如果这是一个库函数，throw可能是适当的操作。

if (!condition1) {
    throw "Condition 1 failed.";
}

if (!condition2) {
    throw "Condition 2 failed.";
}

if (!condition3) {
    throw "Condition 3 failed.";
}

// Superb!

其他可接受的操作可能是：

  • 返回0,null或undefined.
  • 向用户显示错误并返回。

您必须确定哪种故障操作适合您的用例。

于 2010-11-24T17:57:10.503 回答
2

看起来您有 3 个要检查的条件和 4 个操作（3 个不同的错误 + 1 个成功）。不幸的是，在一般情况下，它将需要 3 个条件检查和 4 个操作。我认为可以通过使用以下结构来清理代码

if (! /* condition 1 */ ) {
  // Error 1
} else if (! /* condition 2 */ ) { 
  // Error 2
} else if (! /* condition 3 */ ) { 
  // Error 3
} else {
  // superb
}
于 2010-11-24T17:59:19.880 回答
1

好吧，您可以使用异常，或者在一个块中使用中断，或者使用多个函数。通常，这需要反转您的条件以使代码以正确的方式排序。

do {
    if (! /* Condition 1 */ ) {
        // Error 1
        break;
    }

    if (! /* Condition 2 */ ) {
        // Error 2
        break;
    }

    if (! /* Condition 3 */ ) {
        // Error 3
        break;
    }

    // Superb!
} while (false);

do-while(false) 循环是一种创建块的方法，您可以在不容忍匿名块的语言中打破该块。它可以很容易地成为一个函数并使用返回，或者一个带有异常的 try-catch。

于 2010-11-24T17:58:00.520 回答
0

你更喜欢这个吗？

if ( /* Condition 1*/ && /* Condition 2*/ && /* Condition 3 */) {
  // Superb!
}
else if (! /* Condition 1*/){
  // Error 1
}
else if (! /* Condition 2*/){
  // Error 2
}
else if (! /* Condition 3*/){
  // Error 3
}
于 2010-11-24T17:57:44.230 回答
0 
if ( ! /* Condition */ ) {
Error 1
throw someSortOfException
}

if (! condition 2){
Error 2
throw someSortOfOtherException
}

if (! condition 3){
Error 3
throw another Exception
}

// Success!

根据情况，您的代码可能更受青睐。例如，您可能希望在某处捕获这些异常。

于 2010-11-24T17:57:58.337 回答
0 
if (!condition1)
    // Error 1 (and exit scope if necessary)

if (!condition2)
    // Error 2 (and exit scope if necessary)

if (!condition3)
    // Error 3 (and exit scope if necessary)

// Superb!
于 2010-11-24T17:58:01.547 回答
0

是的; 您可以if使用 AND 运算符将语句组合成单个复合语句，并在单个块中处理错误条件。但是，根据您的错误处理需求，您可能需要再次拥有多个ifs 以确保您正确处理错误（这实际上取决于您的错误处理解决方案）。

以机智：

if (CondA && CondB && CondC)
   {
   // Execute success
   }
else
   {
   if (!CondA)
      // Do error A
   else if (!CondB)
      // Do error B
   else if (!CondC)
     // Do error C
   }
}
于 2010-11-24T17:58:31.307 回答
0

有几种方法，最简单的方法是简单地破坏一些函数并抽象出不同的层（如果你发现自己深入的话，无论如何都应该这样做。）

if ( /* Condition */ ) {
    value = aFunctionSaysWhat();
} else {
  // value = Error 1
}

....
value aFunctionSaysWhat(){
    if ( /* Condition */ ) {
         return aSecondFunctionHere();
    } else {
      // return Error 2
    }
}

基本前提是，如果可能，函数应该存在于抽象层上，并且只做一件事。

下一个可能性是将其全部展平，这优于您最初的嵌套方法，但基本上具有相似的复杂性。如果您只有几个选项并且不打算添加更多选项，它可能比函数式方法更简洁。

if(ErrorCondition1){
   //Error 1
}else if(ErrorCondition2){
   //Error 2
}else if(ErrorCondition3){
   //Error 3
}else{
   //Superb
}

最后，您可以存储带有所需答案的哈希或映射并完全删除 if，实现此功能的能力取决于您对某些结果进行哈希处理的能力：

Results = {'Result1':'Error1', 'Result2':'Error2', 'Result3':'Error3', 'Success':'Superb'}

return Results[ConditionHash(Condition)];
于 2010-11-24T17:59:53.497 回答