Warum würden Sie eine Aufgabe in einer Bedingung verwenden?

Question

In vielen Sprachen sind Zuweisungen in Bedingungen legal. Ich habe den Grund dafür nie verstanden. Warum würden Sie schreiben:

if (var1 = var2) { 
    ... 
} 

statt:

var1 = var2; 
if (var1) { 
    ... 
} 

Answer 1

Es ist nützlicher für Schleifen als if-Anweisungen.

while(var = GetNext()) 
{ 
    ...do something with var 
} 

die sonst

var = GetNext(); 
while(var) 
{ 
...do something 
var = GetNext(); 
} 

Answer 2

Es kann nützlich sein, wenn Sie eine Funktion aufrufen, die sind entweder Daten zurück zu arbeiten oder eine Fahne um einen Fehler anzuzeigen (oder dass Sie sind fertig).

Etwas wie:

while ((c = getchar()) != EOF) { 
    // process the character 
} 

// end of file reached... 

persönlich ist es ein Idiom ich nicht sehr groß lieb bin, aber manchmal ist die Alternative hässliche.

Answer 3

Es ist nützlicher, wenn Sie eine Funktion aufrufen:

if (n = foo()) 
{ 
    /* foo returned a non-zero value, do something with the return value */ 
} else { 
    /* foo returned zero, do something else */ 
} 

Sicher, können Sie einfach die n setzen = foo(); auf eine separate Aussage dann, wenn (n), aber ich denke, das oben genannte ist ein ziemlich lesbares Idiom.

Answer 4

Das Idiom ist nützlicher, wenn Sie eine while Schleife statt einer if Anweisung schreiben. Für eine if-Anweisung können Sie sie wie beschrieben aufteilen. Aber ohne dieses Konstrukt, würden Sie entweder selbst wiederholen:

c = getchar(); 
while (c != EOF) { 
    // ... 
    c = getchar(); 
} 

oder verwenden Loop-and-a-half-Struktur:

while (true) { 
    c = getchar(); 
    if (c == EOF) break; 
    // ... 
} 

Ich würde in der Regel die Schleife-and-a- bevorzugen halbe Form.

Answer 5

GCC kann Ihnen helfen (mit -Wall) zu erkennen, wenn Sie versehentlich versuchen, einen Auftrag als Wahrheitswert zu verwenden, falls es Sie

if ((n = foo())) { 
    ... 
} 

schreiben empfiehlt D.h. verwendet zusätzliche Klammer, um anzuzeigen, dass dies wirklich das, was Sie wollen.

Answer 6

In PHP, zum Beispiel geschrieben werden müßte, ist es nützlich zum Durchschleifen SQL-Datenbank Ergebnisse:

while ($row = mysql_fetch_assoc($result)) { 
    // Display row 
} 

Das sieht viel besser als:

$row = mysql_fetch_assoc($result); 
while ($row) { 
    // Display row 
    $row = mysql_fetch_assoc($result); 
} 

Answer 7

Ich finde es sehr nützlich in Ketten von Handlungen, die oft Fehlererkennung beinhaltet, usw.

if ((rc = first_check(arg1, arg2)) != 0) 
{ 
    report error based on rc 
} 
else if ((rc = second_check(arg2, arg3)) != 0) 
{ 
    report error based on new rc 
} 
else if ((rc = third_check(arg3, arg4)) != 0) 
{ 
    report error based on new rc 
} 
else 
{ 
    do what you really wanted to do 
} 

Die Alternative (nicht die Zuordnung in der Bedingung verwendet wird) ist:

rc = first_check(arg1, arg2); 
if (rc != 0) 
{ 
    report error based on rc 
} 
else 
{ 
    rc = second_check(arg2, arg3); 
    if (rc != 0) 
    { 
     report error based on new rc 
    } 
    else 
    { 
     rc = third_check(arg3, arg4); 
     if (rc != 0) 
     { 
      report error based on new rc 
     } 
     else 
     { 
      do what you really wanted to do 
     } 
    } 
} 

Mit langwieriger Fehlerüberprüfung kann die Alternative, um die rechte Seite von der Seite, während der Zuweisung-in-bedingte Version ablaufen macht das nicht.

Answer 8

Die kurze Antwort ist, dass Expression-oriented Programmiersprachen mehr prägnanten Code erlauben. Das zwingen Sie nicht zu separate commands from queries.

Answer 9

Der andere Vorteil kommt während der Verwendung von gdb. Im folgenden Code ist der Fehlercode nicht bekannt, wenn wir auf Einzelschritt waren.

while (checkstatus() != -1) { 
    // process 
} 

Eher

while (true) { 
    int error = checkstatus(); 
    if (error != -1) 
     // process 
    else 
     //fail 
} 

Jetzt während Schritt können wir wissen, was die Rückkehr Fehlercode aus dem check (war).

Answer 10

Der Grund dafür ist:

1. Leistungsverbesserung (manchmal)

2. Lesser-Code (Immer)

ein Beispiel: Es gibt eine Methode someMethod() und in eine if Bedingung, die Sie überprüfen möchten, ob der Rückgabewert der Methode null ist. Wenn nicht, werden Sie den Rückgabewert erneut verwenden.

If(null != someMethod()){ 
    String s = someMethod(); 
    ...... 
    //Use s 
} 

Es wird die Leistung beeinträchtigen, da Sie die gleiche Methode zweimal aufrufen. Stattdessen verwenden:

String s; 
If(null != (s = someMethod())) { 
    ...... 
    //Use s 
}