Warum würden Sie einen Auftrag in einer Bedingung verwenden?

Question

In vielen Sprachen sind Zuweisungen rechtliche Bedingungen. Ich habe nie verstanden, den Grund für diese. Warum würden Sie schreiben:

if (var1 = var2) {
  ...
}

statt:

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

Answer 1

Es ist sinnvoller für Schleifen als if-Anweisungen.

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

Was sonst geschrieben werden würde

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

Answer 2

Es ist sinnvoller, 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 einer separaten Erklärung dann, wenn (n), aber ich denke, das über eine ziemlich lesbar Idiom ist.

Answer 3

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

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.

first_action(), second_action(), third_action() - -

Die Fehlerprüfungen könnten auch ‚Aktionen‘ sein natürlich, und nicht nur überprüft. Das heißt, dass sie Schritte im Prozess überprüft werden, dass die Funktion Verwaltung ist. (Meistens im Code mit denen ich arbeite, sind die Funktionen entlang der Linien von Voraussetzung Schecks oder Speicherzuordnungen, die für die Funktion zu arbeiten, oder entlang ähnlicher Linien).

Answer 4

Es kann nützlich sein, wenn Sie eine Funktion aufrufen, die sind entweder Daten zu arbeiten oder ein Flag gibt einen Fehler anzuzeigen (oder dass Sie fertig sind).

So 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 5

GCC können Sie (mit -Wall) helfen, festzustellen, ob Sie versehentlich versuchen, einen Auftrag als Wahrheitswert zu verwenden, falls es empfiehlt schreiben

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

d. verwendet zusätzliche Klammer, um anzuzeigen, dass dies wirklich das, was Sie wollen.

Answer 6

Das Idiom ist nützlich, wenn Sie eine while Schleife statt einer if Anweisung zu schreiben. Für eine if Anweisung, können Sie es brechen, wie Sie beschreiben. Aber ohne dieses Konstrukt, würden Sie entweder selbst wiederholen:

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

oder verwenden, um eine Schleife-und-ein-halb-Struktur:

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

würde ich in der Regel bevorzugt die Schleife-and-a-hilft Form.

Answer 7

Die kurze Antwort ist, dass Expression orientierte Programmiersprachen prägnanter Code ermöglichen. Sie zwingen Sie nicht zu separaten Befehlen von Abfragen .

Answer 8

In PHP, zum Beispiel, es ist nützlich für die Schleife durch 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 9

Der andere Vorteil kommt bei der Verwendung von gdb. Im folgenden Code wird der Fehlercode nicht bekannt, ob wir zu Schritt waren.

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

Rather

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. Performance-Verbesserung (manchmal)

2. Lesser-Code (immer)

Nehmen wir ein Beispiel: Es gibt ein Verfahren someMethod() und in einem if Zustand wollen Sie, ob der Rückgabewert der Methode überprüfen null ist. Wenn nicht du gehst wieder den Rückgabewert zu 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
}