Question

boolean f(boolean A, boolean B, boolean C, boolean D, boolean E)
{
  if (A)
  {
    k();
    if (B)
    {
      m();
      if (C)
      {
        n();
        if (D)
        {
          p();
          if (E)
          {
            q();
            return true;
          }
          else
          {
            r();
            return false;
          }
        }
        else
        {
          s();
          return false;
        }
      }
      else
      {
        t();
        return false;
      }
    }
    else
    {
      v();
      return false;
    }
  }
  else
  {
    w();
    return false;
  }
}

Answer 1

如果不了解您正在解决的问题，我会将其重写为

boolean f(boolean A, boolean B, boolean C, boolean D, boolean E)
{
  if (A) k();
  if (A && B) m();
  if (A && B && C) n();
  if (A && B && C && D) p();
  if (A && B && C && D && E) { q(); return true; }
  if (A && B && C && D && !E) { r(); return false; }
  if (A && B && C && !D) { s(); return false; }
  if (A && B && !C) { t(); return false; }
  if (A && !B) { v(); return false; }
  if (!A) { w(); return false; }
}

在我看来，这使得跟踪场景变得更容易一些然而，这仍然是绝对可怕的。您最想要的是某种算法模式，其中不同的行为被强制为实现相同接口的不同类，您可以选择基于多态的行为，或者在创建对象时注入算法。
基本上每个采用多个布尔参数的方法都是代码气味。

Answer 2

可能只是通过不止一次评估条件来展平if：

if (A) k(); else w();
if (A && B) m(); else if(A && !B) v();
if (A && B && C) n(); else if (A && B && !C) t();
if (A && B && C && D) p(); else if (A && B && C && !D) s();
if (A && B && C && D && E) q(); else if (A && B && C && D && !E) r();

return (A && B && C && D && E);

Answer 3

如果调用方法的顺序不重要，那么：

failedOnce = false
for ar as Array in [
    (A, K, W)
    (B, M, V)
    (C, N, T)
    (D, P, S)
    (E, Q, R)
    ]:
    if ar[0]:
        ar[1].Invoke()
    else:
        ar[2].Invoke()
        break
        failedOnce = false

return not failedOnce

Answer 4

我被要求在最近的求职面试中优化此代码。

这是我提出的代码版本：

boolean f(boolean A, boolean B, boolean C, boolean D, boolean E )
{
    boolean success = false;

    // I use "==false" because it's more readable than "if !A"
    if(A == false)
    {
        w();
    } else {
        if(B == false)
        {
            v();
        } else {
            m();
            if(C == false)
            {
                n();
                if(D == false)
                {
                    s();
                } else {
                    if(E == false)
                    {
                        r();
                    } else {
                        q();
                        success = true;
                    }
                }
            }
        }
    }

    // this will be "false" in all cases except one
    return (success);
}

我的答案背后的逻辑是试图保持可读性，同时减少“回报”的数量。

以下是招聘人员真正寻找的答案：

boolean f(Boolean A, Boolean B, Boolean C, Boolean D, Boolean E)
{
    boolean result = false;

    do
    {
        if (!A)
        {
            w();
            break;
        }

        k();
        if (!B)
        {
            v();
            break;
        }

        m();
        if (!C)
        {
            t();
            break;
        }

        n();
        if (!D)
        {
            s();
            break;
        }

        p();
        if (!E)
        {
            r();
            break;
        }

        // All conditions satisfied
        result = true;

    } while (false);

    return result;
}

这会使用wily do-once-only-once-once循环，并在某些条件失败时使用“break”的概念。

我该如何简化此代码？

4 个答案: