it-swarm.com.de

Der beste Weg, eine if-Anweisung mit mehreren Bedingungen zu formatieren

Wenn Sie einen Code ausführen möchten, der auf zwei oder mehr Bedingungen basiert, welcher ist der beste Weg, diese if-Anweisung zu formatieren?

erstes Beispiel: -

if(ConditionOne && ConditionTwo && ConditionThree)
{
   Code to execute
}

Zweites Beispiel: -

if(ConditionOne)
{
   if(ConditionTwo )
   {
     if(ConditionThree)
     {
       Code to execute
     }
   }
}

dies ist am einfachsten zu verstehen und zu lesen, wenn man bedenkt, dass jede Bedingung ein langer Funktionsname oder etwas anderes sein kann.

81
Matt690

Ich bevorzuge Option A

bool a, b, c;

if( a && b && c )
{
   //This is neat & readable
}

Wenn Sie besonders lange Variablen/Methoden-Bedingungen haben, können Sie diese einfach in Zeilenumbrüche setzen

if( VeryLongConditionMethod(a) &&
    VeryLongConditionMethod(b) &&
    VeryLongConditionMethod(c))
{
   //This is still readable
}

Wenn sie noch komplizierter sind, würde ich in Betracht ziehen, die Bedingungsmethoden separat außerhalb der if-Anweisung auszuführen

bool aa = FirstVeryLongConditionMethod(a) && SecondVeryLongConditionMethod(a);
bool bb = FirstVeryLongConditionMethod(b) && SecondVeryLongConditionMethod(b);
bool cc = FirstVeryLongConditionMethod(c) && SecondVeryLongConditionMethod(c);

if( aa && bb && cc)
{
   //This is again neat & readable
   //although you probably need to sanity check your method names ;)
}

IMHO Der einzige Grund für die Option 'B' wäre, wenn Sie für jede Bedingung separate else -Funktionen ausführen müssten.

z.B.

if( a )
{
    if( b )
    {
    }
    else
    {
        //Do Something Else B
    }
}
else
{
   //Do Something Else A
}
123
Eoin Campbell

Andere Antworten erklären, warum die erste Option normalerweise die beste ist. Wenn Sie jedoch mehrere Bedingungen haben, ziehen Sie in Betracht, eine separate Funktion (oder Eigenschaft) für die Bedingungsprüfungen in Option 1 zu erstellen. Dies erleichtert das Lesen des Codes erheblich, zumindest wenn Sie gute Methodennamen verwenden.

if(MyChecksAreOk()) { Code to execute }

...

private bool MyChecksAreOk()
{ 
    return ConditionOne && ConditionTwo && ConditionThree;
}

Wenn die Bedingungen nur von lokalen Bereichsvariablen abhängen, können Sie die neue Funktion statisch machen und alles übergeben, was Sie benötigen. Wenn es eine Mischung gibt, geben Sie die lokalen Sachen ein.

28
Torbjørn

Das erste Beispiel ist "leichter zu lesen".

Eigentlich sollten Sie meiner Meinung nach immer nur die zweite verwenden, wenn Sie eine "else-Logik" hinzufügen müssen, aber für eine einfache Bedingung verwenden Sie die erste Variante. Wenn Sie sich Sorgen über die Dauer der Bedingung machen, können Sie immer die folgende Syntax verwenden:

if(ConditionOneThatIsTooLongAndProbablyWillUseAlmostOneLine
                 && ConditionTwoThatIsLongAsWell
                 && ConditionThreeThatAlsoIsLong) { 
     //Code to execute 
}

Viel Glück!

10

Die Frage wurde gestellt und bisher so beantwortet, als ob die Entscheidung nur aus "syntaktischen" Gründen getroffen werden sollte.

Ich würde sagen, dass die richtige Antwort darauf, wie Sie eine Reihe von Bedingungen innerhalb eines if auslegen, sollte auch von der "Semantik" abhängen sollte. Die Bedingungen sollten also aufgeteilt und danach gruppiert werden, was "konzeptionell" zusammengehört.

Wenn zwei Tests wirklich zwei Seiten einer Medaille sind, z. wenn (x> 0) && (x <= 100), dann füge sie in derselben Zeile zusammen. Wenn eine andere Bedingung konzeptionell weit entfernter ist, z. user.hasPermission (Admin ()) setzt es dann in eine eigene Zeile

Z.B.

if user.hasPermission(Admin()) {
   if (x >= 0) && (x < 100) {
      // do something
   }
}
9
interstar
    if (   ( single conditional expression A )
        && ( single conditional expression B )
        && ( single conditional expression C )
       )
    {
       opAllABC();
    }
    else
    {
       opNoneABC();
    }

Formatting a multiple conditional expressions in an if-else statement this way:
1) allows for enhanced readability:
    a) all binary logical operations {&&, ||} in the expression shown
       first
    b) both conditional operands of each binary operation are obvious
       because they align vertically
    c) nested logical expressions operations are made obvious using
       indentation, just like nesting statements inside clause
2) requires explicit parenthesis (not rely on operator precedence rules)
    a) this avoids a common static analysis errors
3) allows for easier debugging
    a) disable individual single conditional tests with just a //
    b) set a break point just before or after any individual test
    c) e.g. ...

    // disable any single conditional test with just a pre-pended '//'
    // set a break point before any individual test
    // syntax '(1 &&' and '(0 ||' usually never creates any real code
    if (   1
        && ( single conditional expression A )
        && ( single conditional expression B )
        && (   0
            || ( single conditional expression C )
            || ( single conditional expression D )
           )
       )
    {
       ... ;
    }

    else
    {
       ... ;
    }
7
Sean

Das zweite ist ein klassisches Beispiel für das Pfeil-Anti-Muster Also würde ich es vermeiden ...

Wenn Ihre Bedingungen zu lang sind, extrahieren Sie sie in Methoden/Eigenschaften.

4
Omar Kooheji

Das erste ist einfacher, denn wenn Sie es von links nach rechts lesen, erhalten Sie: "Wenn etwas AND somethingelse AND somethingelse THEN", was ein leicht verständlicher Satz ist. Das zweite Beispiel lautet "Wenn etwas dann wenn etwas anderes dann dann", was ungeschickt ist.

Überlegen Sie auch, ob Sie in Ihrer Klausel einige ORs verwenden möchten - wie würden Sie das im zweiten Stil tun?

3
RB.

Ich glaube switch...case Anweisung ist der beste Weg, um unter diesen Umständen sauberen Code zu schreiben, wenn die Programmiersprache dies unterstützt.

switch (//variable or Boolean) {
  case //Condition A:
  case //Condition B:
  case //Condition C:
    //Code to execute;
}
2
Kent

In Perl können Sie dies tun:

{
  ( VeryLongCondition_1 ) or last;
  ( VeryLongCondition_2 ) or last;
  ( VeryLongCondition_3 ) or last;
  ( VeryLongCondition_4 ) or last;
  ( VeryLongCondition_5 ) or last;
  ( VeryLongCondition_6 ) or last;

  # Guarded code goes here
}

Wenn eine der Bedingungen fehlschlägt, wird sie nach dem Blockieren fortgesetzt. Wenn Sie Variablen definieren, die Sie nach dem Block beibehalten möchten, müssen Sie sie vor dem Block definieren.

0
Brad Gilbert