Stylingverbindung UND / ODER wenn Anweisungen

Wie gestalten Sie komplexe zusammengesetzte AND / OR if-Anweisungen für maximale Lesbarkeit? Wie rücken Sie ein und wo platzieren Sie die Zeilenumbrüche? Meine besondere Situation ist in etwa wie folgt. Es ist definitiv besser als alles in eine Zeile zu zerschlagen, sieht aber immer noch chaotisch aus.

if (
    (
        x == y
        && a != b
        && p.isGood() 
        && (
            i + u == b
            || q >= a
        )
    )
    || k.isSomething()
    || m > n
) {
    doSomething();
}

Machen Sie für jeden kleinen Schritt boolesche Variablen:

bool step1 = i + u == b || q >= a;
bool step2 = a != b && p.isGood() && group1;
bool step3 = group2 || k.isSomething() || m > n;
if (step3) { doSomething(); }

Dies ist natürlich der Antwort von Lacrymology ähnlich, außer dass für jeden Schritt andere Namen verwendet werden.

Wenn Sie benennen step1, step2und step3in einer Weise , die guten konzeptionellen Sinn machen, soll dies mit Abstand der meisten lesbar. p.isGood()und k.isSomething()kann manchmal in Situationen aufgerufen werden, in denen es nicht in Ihrem ursprünglichen Code wäre, so wäre dies keine Option, wenn diese Funktionen teuer sind oder wenn Sie diesen Code in einer sehr engen Schleife ausführen.

Auf der anderen Seite brauchen Sie sich keine Sorgen über die Leistung zu machen, die durch das Erstellen neuer Variablen entstehen könnte. Ein guter Compiler wird sie optimieren.

Ein Beispiel mit Rechteckkollisionserkennung (die Sie aufgrund des oben genannten Leistungseinbruchs wahrscheinlich nicht verwenden würden):

if((a.x + a.width >= b.x || b.x + b.width >= a.x)
 && (a.y + a.height >= b.y || b.y + b.width >= a.y)
)
{ collision(); }

Könnte werden:

bool horizMatch = a.x + a.width >= b.x || b.x + b.width >= a.x;
bool vertMatch = a.y + a.height >= b.y || b.y + b.width >= a.y;
if(horizMatch && vertMatch) { collision(); }

Auch wenn Sie Ihren Code so lassen möchten, wie er ist, wäre das meiner Meinung nach auch völlig in Ordnung. Ich denke ehrlich, dass Ihr Code gut lesbar ist. Offensichtlich weiß ich nicht genau, was genau a b x y i u p k m nist, aber was die Struktur angeht, sieht es für mich gut aus.

Normalerweise verändere ich meinen Code, um modularer zu sein, wenn meine Bedingungen so kompliziert werden.

Ich würde so etwas eher machen, auf dieser Ebene der Komplexität

bool doIt = x == y && a != b && p.isGood();
doIt &= ( i + u == b || q >= a);
doIt |= k.isSomething() || m > n;

if(doIt)
{
    doSomething();
}

Es ist hässlich, aber lesbar und ich bin mir ziemlich sicher, dass der Compiler weiß, wie er es umgestalten kann.

Wenn ich mich jedoch jemals in der Situation befinde, eine solche IF-Anweisung zu schreiben, überlege ich mir die Lösung neu, da ich BESTIMMT bin, dass es eine Möglichkeit gibt, dies einfacher zu machen oder zumindest einige dieser Bedingungen zu abstrahieren (z. B .: Vielleicht x == y && a != b && p.isGood()wirklich nur gemein this->isPolygon()und ich kann diese Methode machen;

Ich bin mit der Zeit weniger besessen von der vertikalen Ausrichtung, aber meine allgemeine Form mit mehrzeiligen Ausdrücken ist ...

if (   (   (expr1 == expr2)
        || (expr3 == expr4)
        || (expr5 == expr6)
       )
    && (   (expr7 == expr8)
        || (expr9 == expra)
       )
   )
{
  blah;
}

Wichtige Punkte ...

• Die geschlossenen Parens werden wie die geschweiften Klammern vertikal zu den offenen Parens ausgerichtet.
• Die Unterausdrücke, die in eine Zeile passen, befinden sich in einer Zeile und sind vertikal links ausgerichtet. Wo dies die Lesbarkeit verbessert, sind die Infix-Operatoren in diesen einzeiligen Teilen ebenfalls vertikal ausgerichtet.
• Die schließenden Klammern erzeugen auf natürliche Weise fast leere Linien und helfen, Dinge visuell zu gruppieren.

Manchmal formatiere ich +und *einige andere Operatoren auch so. Nicht wenige komplexe Ausdrücke haben eine Produkt-Summe- oder eine Produkt-Summe-Form (die sich auf boolesche "Summen" und "Produkte" beziehen kann), sodass es wahrscheinlich häufig genug ist, dass sich ein konsistenter Stil dafür lohnt.

Aber sei vorsichtig damit. Es ist oft besser, eine Umgestaltung vorzunehmen (Teile des Ausdrucks in eine Funktion zu verschieben oder Zwischenteile in einer Variablen zu berechnen und zu speichern), als Einrückungen zu verwenden, um zu versuchen, einen überkomplexen Ausdruck lesbarer zu machen.

Wenn Sie es vorziehen, Ihre Close-Parens auf der rechten Seite zu stapeln, hasse ich es nicht , aber ich denke, es ist nicht so schlimm. Wenn Sie zu weit gehen, laufen Sie Gefahr, dass der Einzug durch einen Fehler falsch dargestellt wird, was die Klammern tun.

if (   (   (expr1 == expr2)
        || (expr3 == expr4)
        || (expr5 == expr6))

    && (   (expr7 == expr8)
        || (expr9 == expra)))
{
  blah;
}

http://www.codinghorror.com/blog/2006/01/flattening-arrow-code.html

Ich stimme der Antwort von JohnFx sowie einer von Lacrymology zu. Ich würde eine Reihe von Funktionen (vorzugsweise statische) erstellen, die kleine Ziele erreichen und diese dann auf intelligente Weise aufbauen.

Also, wie wäre es mit so etwas? Beachten Sie, dass dies nicht die perfekte Lösung ist, aber es funktioniert. Es gibt Möglichkeiten, dies weiter zu bereinigen, es sind jedoch spezifischere Informationen erforderlich. Hinweis: Dieser Code sollte genauso schnell laufen, denn der Compiler ist schlau.

// Currently based on members or global vars
// (which is often a bad idea too)
function doSomethingCondirionally()
{
  if (k.isSomething() || m > n)
  {
    doSomething();
    return;
  }

  // Else ... 
  if (x != y) return;
  if (a == b) return;
  if (!p.isGood()) return;

  // Final, positive check
  if (i + u == b || q >= a)
  {
    doSomething();
  }
}

Für das, was es wert ist, war ich überrascht zu sehen, dass Ihr Beispiel den komplizierten Prädikaten, die ich geschrieben habe, sehr ähnlich sieht. Ich stimme anderen zu, dass ein kompliziertes Prädikat für die Wartbarkeit oder Lesbarkeit nicht das beste ist, aber gelegentlich tauchen sie auf.

Lassen Sie mich betonen, dass Sie diesen Teil richtig gemacht haben: Setzen Sie && a != b NIEMALS einen logischen Konnektor an das Ende einer Zeile, es ist zu leicht, ihn visuell zu übersehen. Eine andere Stelle, an der Sie NIEMALS einen Operator ans Ende der Zeile setzen sollten, ist die Verkettung von Zeichenfolgen in Sprachen mit einem solchen Operator.

Mach das:

String a = b
   + "something"
   + c
   ;

Mach das nicht:

String a = b +
   "something" +
   c;

Wenn die Bedingung so kompliziert ist, ist dies normalerweise ein Hinweis darauf, dass sie in Teile zerlegt werden sollte. Möglicherweise kann einer Zwischenvariablen eine Klausel zugewiesen werden. Vielleicht kann eine Klausel in eine Hilfsmethode umgewandelt werden. Im Allgemeinen bevorzuge ich es, nicht so viele Ands und Ors in einer Zeile zu haben.

Sie können den Code in mehrere Anweisungen aufteilen, um das Verständnis zu vereinfachen. Aber ein echter Ninja würde so etwas tun. :-)

if
(
    (
        x == y
    &&
        a != b
    &&
        p.isGood()
    &&
        (
            i + u == b
        ||
            q >= a
        )
    )
||
    k.isSomething()
||
    m > n
)
{
    doSomething();
}