Ist es schlecht, explizit mit booleschen Konstanten zu vergleichen, z. B. wenn (b == false) in Java?

Ist es schlecht zu schreiben:

if (b == false) //...

while (b != true) //...

Ist es immer besser stattdessen zu schreiben:

if (!b) //...

while (!b) //...

Vermutlich gibt es keinen Unterschied in der Leistung (oder gibt es?), Aber wie bewerten Sie die Aussagekraft, die Prägnanz, die Klarheit, die Lesbarkeit usw. zwischen den beiden?

Aktualisieren

Um die Subjektivität einzuschränken, würde ich mich auch über Zitate aus Richtlinien für maßgebliche Codierungsstile freuen, die immer vorzuziehen sind oder wann verwendet werden sollen.

Hinweis : Der Variablenname bwird nur als Beispiel verwendet, ala foound bar.

Es ist nicht unbedingt schlecht, es ist nur überflüssig. Auch der tatsächliche Variablenname hat viel Gewicht. Ich würde zum Beispiel if (userIsAllowedToLogin)oben if (b)oder noch schlimmer bevorzugen if (flag).

Das Leistungsproblem wird vom Compiler in keiner Weise optimiert.

Update : In Bezug auf die maßgeblichen Quellen kann ich in den Sun Coding Conventions nichts explizit finden , aber zumindest hat Checkstyle ein SimplifyBooleanExpressionModul, das davor warnt.

Sie sollten nicht den ersten Stil verwenden. Ich habe gesehen, wie Leute Folgendes benutzten:

• if ( b == true )
• if ( b == false )

Ich persönlich finde es schwer zu lesen, aber es ist passabel. Ein großes Problem, das ich mit diesem Stil habe, ist jedoch, dass es zu den unglaublich kontraintuitiven Beispielen führt, die Sie gezeigt haben:

• if ( b != true )
• if ( b != false )

Dies erfordert vom Leser mehr Aufwand, um die Absicht des Autors zu bestimmen. Persönlich finde ich einen expliziten Vergleich mit wahr oder falsch überflüssig und damit schwerer zu lesen, aber das bin ich.

Dies ist stark Geschmackssache.

Persönlich habe ich festgestellt, dass dies if (!a) {viel weniger lesbar ist (BEARBEITEN: für mich) als if (a == false) {und daher fehleranfälliger, wenn der Code später gepflegt wird, und ich habe konvertiert, um das letztere Formular zu verwenden.

Grundsätzlich mag ich die Auswahl von Symbolen für logische Operationen anstelle von Wörtern nicht (C gegen Pascal), weil für mich das a = 10 and not b = 20 Lesen einfacher ist als a == 10 && !(b==20), aber so ist es in Java.

Jeder, der den Ansatz "== false" zugunsten von "!" Offensichtlich hatte ich nie zu lange auf Code gestarrt und dieses Ausrufezeichen übersehen. Ja, Sie können Code-blind werden.

Der Hauptgrund, warum Sie den ersten Stil nicht verwenden sollten, ist, dass beide gültig sind:

if (b = false) //...

while (b = true) //...

Das heißt, wenn Sie versehentlich ein Zeichen weglassen, erstellen Sie eine Zuordnung anstelle eines Vergleichs. Ein Zuweisungsausdruck wertet den zugewiesenen Wert aus, daher weist die erste obige Anweisung den Wert falsezu bund wertet ihn aus false. Der zweite Abtretungsempfänger truezu b, so dass es immer auswertet true, egal , was Sie mit zu tun bin der Schleife.

Ersteres habe ich nie gesehen, außer in Code, der von Anfängern geschrieben wurde. es ist immer das letztere, und ich glaube nicht, dass irgendjemand wirklich verwirrt ist. Auf der anderen Seite denke ich

int x;
...
if(x) //...

vs.

if(x != 0) //...

ist viel umstrittener, und in diesem Fall bevorzuge ich die zweite

IMHO, ich denke, wenn Sie nur die Bool-Variablennamen voranstellen "Is", wird dies selbstverständlich und aussagekräftiger, und dann können Sie den expliziten Vergleich mit trueoder entfernenfalse

Beispiel:

isEdited  // use IsEdited in case of property names
isAuthorized // use IsAuthorized in case of property names

etc

Ich bevorzuge das erste, weil es klarer ist. Die Maschine kann entweder gleich gut lesen, aber ich versuche , Code zu schreiben , für andere Menschen zu lesen, nicht nur die Maschine.

Ich ziehe den langen Ansatz, aber ich vergleiche mit ==anstelle von !=99% der Zeit.

Ich weiß, dass es sich bei dieser Frage um Java handelt, aber ich C#wechsle oft zwischen Sprachen, und zum Beispiel kann ein Vergleich mit (für isntance) == falsehilfreich sein, wenn es um nullfähige Bool- Typen geht. Also habe ich die Gewohnheit, mit dem Operator zu vergleichen trueoder ihn zu falsebenutzen ==.

Ich mache diese:

if(isSomething == false) oder if(isSomething == true)

aber ich hasse diese:

if(isSomething != false) oder if(isSomething != true)

aus offensichtlichen Gründen der Lesbarkeit!

Solange Sie Ihren Code lesbar halten, spielt dies keine Rolle.

Persönlich würde ich den Code umgestalten, damit ich keinen negativen Test verwende. zum Beispiel.

if (b == false) {
   // false
} else {
   // true
}

oder

boolean b = false;
while(b == false) {
  if (condition)
      b = true;
}

IMHO, In 90% der Fälle kann Code überarbeitet werden, sodass der negative Test nicht erforderlich ist.

Meiner Meinung nach ist es einfach nervig. Nicht etwas, worüber ich einen Aufruhr verursachen würde.

Die normale Richtlinie ist, niemals gegen Boolesche Werte zu testen. Einige argumentieren, dass die zusätzliche Ausführlichkeit zur Klarheit beiträgt. Der hinzugefügte Code kann einigen Leuten helfen, aber jeder Leser muss mehr Code lesen.

Heute Morgen habe ich eine halbe Stunde verloren, um einen Fehler zu finden. Der Code war

    if ( !strcmp(runway_in_use,"CLOSED") == IPAS_FALSE)
      printf(" ACTIVE    FALSE \n");   else
      printf(" ACTIVE    TRUE \n");

Wenn es mit normaler Konvention codiert worden wäre, hätte ich viel schneller gesehen, dass es falsch war:

    if (strcmp(runway_in_use, "CLOSED"))
      printf(" ACTIVE    FALSE \n");   else
      printf(" ACTIVE    TRUE \n");

Dies ist meine erste Antwort auf StackOverflow, also sei nett ... Vor kurzem habe ich beim Refactoring festgestellt, dass 2 Codeblöcke fast genau den gleichen Code hatten, aber einer verwendet hatte

for (Alert alert : alerts) {
    Long currentId = alert.getUserId();

    if (vipList.contains(currentId)) {
        customersToNotify.add(alert);

        if (customersToNotify.size() == maxAlerts) {
            break;
        }
    }
}

und der andere hatte

for (Alert alert : alerts) {
    Long currentId = alert.getUserId();

    if (!vipList.contains(currentId)) {
        customersToNotify.add(alert);

        if (customersToNotify.size() == maxAlerts) {
            break;
        }
    }
}

In diesem Fall war es also sinnvoll, eine Methode zu erstellen, die für beide Bedingungen wie diese funktioniert, indem boolean == conditiondie Bedeutung umgedreht wird

private void appendCustomersToNotify(List<Alert> alerts
        List<Alert> customersToNotify, List<Long> vipList, boolean vip){

    for (Alert alert : alerts) {
        Long currentId = alertItem.getUserId();

        if (vip == vipList.contains(currentId)) {
            customersToNotify.add(alertItem);

            if (customersToNotify.size() == maxAlerts) {
                break;
            }
        }
    }
}

Ich würde sagen, es ist schlecht.

while (!b) {
    // do something 
}

liest sich viel besser als

while (b != true) {
    // do something 
}

Einer der Gründe, warum der erste (b == false) verpönt ist, ist, dass Anfänger oft nicht erkennen, dass die zweite Alternative (! B) überhaupt möglich ist. Die Verwendung der ersten Form kann also auf ein Missverständnis mit booleschen Ausdrücken und booleschen Variablen hinweisen. Auf diese Weise ist die Verwendung der zweiten Form zu einer Art Sjiboleth geworden: Wenn jemand dies schreibt, versteht er / sie wahrscheinlich, was los ist.

Ich glaube, dass dies dazu geführt hat, dass der Unterschied als wichtiger angesehen wird als er wirklich ist.

Während beide gültig sind, fühlt sich der erste für mich wie ein Tippfehler an.

Für mich b == falsesieht das genauso falsch aus wie (i == 0) == false. Es ist wie: huh?

Boolesche Werte sind keine Aufzählung mit 2 möglichen Werten. Sie vergleichen sie nicht. Boolesche Werte sind Prädikate und repräsentieren eine Wahrheit. Sie haben ganz bestimmte Operatoren wie &, |, ^, !.

Um die Wahrheit eines Ausdrucks umzukehren, verwenden Sie den Operator '!' Und sprechen Sie ihn als "nicht" aus.

Bei richtiger Benennung wird es natürlich: !isEmptyliest "nicht ist leer", für mich gut lesbar.
Während isEmpty == falseliest sich etwas wie "es ist falsch, dass es leer ist", was ich mehr Zeit brauche, um zu verarbeiten.