Vorteile der Verwendung des bedingten ?: (Ternären) Operators

Was sind die Vor- und Nachteile des ?: Operators im Gegensatz zur Standard-if-else-Anweisung. Die offensichtlichen sind:

Bedingt?: Operator

• Kürzer und prägnanter beim Umgang mit direkten Wertevergleichen und Zuordnungen
• Scheint nicht so flexibel zu sein wie das if / else-Konstrukt

Standard If / Else

• Kann auf mehrere Situationen angewendet werden (z. B. Funktionsaufrufe)
• Oft sind sie unnötig lang

Die Lesbarkeit scheint je nach Aussage unterschiedlich zu sein. Nachdem ich dem Operator ?: Zum ersten Mal ausgesetzt war, brauchte ich eine Weile, um genau zu verstehen, wie es funktionierte. Würden Sie empfehlen, es wo immer möglich zu verwenden oder sich daran zu halten, wenn ich mit vielen Nicht-Programmierern zusammenarbeite?

Ich würde grundsätzlich empfehlen, es nur zu verwenden, wenn die resultierende Aussage extrem kurz ist und eine signifikante Erhöhung der Prägnanz gegenüber dem if / else-Äquivalent darstellt, ohne die Lesbarkeit zu beeinträchtigen.

Gutes Beispiel:

int result = Check() ? 1 : 0;

Schlechtes Beispiel:

int result = FirstCheck() ? 1 : SecondCheck() ? 1 : ThirdCheck() ? 1 : 0;

Dies wird so ziemlich von den anderen Antworten abgedeckt, aber "es ist ein Ausdruck" erklärt nicht wirklich, warum das so nützlich ist ...

In Sprachen wie C ++ und C # können Sie damit lokale schreibgeschützte Felder (innerhalb eines Methodenkörpers) definieren. Dies ist mit einer herkömmlichen if / then-Anweisung nicht möglich, da der Wert eines schreibgeschützten Felds innerhalb dieser einzelnen Anweisung zugewiesen werden muss:

readonly int speed = (shiftKeyDown) ? 10 : 1;

ist nicht dasselbe wie:

readonly int speed;  
if (shifKeyDown)  
    speed = 10;    // error - can't assign to a readonly
else  
    speed = 1;     // error  

Auf ähnliche Weise können Sie einen tertiären Ausdruck in anderen Code einbetten. Der Quellcode wird nicht nur kompakter (und in einigen Fällen dadurch besser lesbar), sondern auch der generierte Maschinencode kompakter und effizienter:

MoveCar((shiftKeyDown) ? 10 : 1);

... kann weniger Code generieren, als dieselbe Methode zweimal aufrufen zu müssen:

if (shiftKeyDown)
    MoveCar(10);
else
    MoveCar(1);

Natürlich ist es auch eine bequemere und präzisere Form (weniger Eingabe, weniger Wiederholung und kann die Wahrscheinlichkeit von Fehlern verringern, wenn Sie Codeblöcke in einem if / else duplizieren müssen). In sauberen "Common Pattern" -Fällen wie diesen:

object thing = (reference == null) ? null : reference.Thing;

... es ist einfach schneller zu lesen / zu analysieren / zu verstehen (sobald Sie daran gewöhnt sind) als das langatmige if / else-Äquivalent, sodass Sie Code schneller "groken" können.

Natürlich nur , weil es ist nützlich , bedeutet nicht , es das Beste ist , zu verwenden , in jedem Fall. Ich würde empfehlen, es nur für kurze Codebits zu verwenden, bei denen die Bedeutung durch Verwendung klar (oder klarer) wird. ?:Wenn Sie es in komplexerem Code verwenden oder ternäre Operatoren ineinander verschachteln, kann es schrecklich schwierig sein, Code zu lesen .

Normalerweise wähle ich einen ternären Operator, wenn ich sonst viel doppelten Code hätte.

if (a > 0)
    answer = compute(a, b, c, d, e);
else
    answer = compute(-a, b, c, d, e);

Mit einem ternären Operator könnte dies wie folgt erreicht werden.

answer = compute(a > 0 ? a : -a, b, c, d, e); 

Ich finde es besonders hilfreich bei der Webentwicklung, wenn ich eine Variable auf einen Wert setzen möchte, der in der Anforderung gesendet wird, wenn sie definiert ist, oder auf einen Standardwert, wenn dies nicht der Fall ist.

Eine wirklich coole Verwendung ist:

x = foo ? 1 :
    bar ? 2 :
    baz ? 3 :
          4;

Der bedingte Operator eignet sich hervorragend für kurze Bedingungen wie diese:

varA = boolB ? valC : valD;

Ich benutze es gelegentlich, weil es weniger Zeit braucht, etwas auf diese Weise zu schreiben ... Leider kann diese Verzweigung manchmal von einem anderen Entwickler übersehen werden, der Ihren Code durchsucht. Außerdem ist der Code normalerweise nicht so kurz, sodass ich normalerweise die Lesbarkeit unterstütze, indem ich das? und: in separaten Zeilen wie folgt:

doSomeStuffToSomething(shouldSomethingBeDone()
    ? getTheThingThatNeedsStuffDone()
    : getTheOtherThingThatNeedsStuffDone());

Der große Vorteil bei der Verwendung von if / else-Blöcken (und warum ich sie bevorzuge) ist jedoch, dass es einfacher ist, später einzutreten und dem Zweig zusätzliche Logik hinzuzufügen.

if (shouldSomethingBeDone()) {
    doSomeStuffToSomething(getTheThingThatNeedsStuffDone());
    doSomeAdditionalStuff();
} else {
doSomeStuffToSomething(getTheOtherThingThatNeedsStuffDone());
}

oder fügen Sie eine andere Bedingung hinzu:

if (shouldSomethingBeDone()) {
    doSomeStuffToSomething(getTheThingThatNeedsStuffDone());
    doSomeAdditionalStuff();
} else if (shouldThisOtherThingBeDone()){
    doSomeStuffToSomething(getTheOtherThingThatNeedsStuffDone());
}

Letztendlich geht es also um Bequemlichkeit für Sie (kürzer zu verwenden :?) Im Vergleich zu Bequemlichkeit für Sie (und andere) später. Es ist ein Urteilsspruch ... aber wie bei allen anderen Problemen bei der Code-Formatierung besteht die einzige wirkliche Regel darin, konsistent und visuell höflich gegenüber denen zu sein, die Ihren Code pflegen (oder bewerten!) Müssen.

(alle Code Auge kompiliert)

Bei der Verwendung des ternären Operators ist zu beachten, dass es sich um einen Ausdruck und nicht um eine Anweisung handelt.

In funktionalen Sprachen wie Schema existiert die Unterscheidung nicht:

(if (> ab) ab)

Bedingt ?: Operator "Scheint nicht so flexibel zu sein wie das if / else-Konstrukt"

In funktionalen Sprachen ist es.

Beim Programmieren in imperativen Sprachen wende ich den ternären Operator in Situationen an, in denen ich normalerweise Ausdrücke (Zuweisung, bedingte Anweisungen usw.) verwenden würde.

Obwohl die obigen Antworten gültig sind und ich der Lesbarkeit zustimme, sind zwei weitere Punkte zu beachten:

1. In C # 6 können Sie Ausdrucksmethoden verwenden.

Dies macht es besonders prägnant, das ternäre zu verwenden:

string GetDrink(DayOfWeek day) 
   => day == DayOfWeek.Friday
      ? "Beer" : "Tea";

2. Das Verhalten unterscheidet sich bei der impliziten Typkonvertierung.

Wenn Sie Typen haben T1und T2dass beide implizit konvertiert werden können T, dann ist die unten tut nicht Arbeit:

T GetT() => true ? new T1() : new T2();

(weil der Compiler versucht, den Typ des ternären Ausdrucks zu bestimmen, und es keine Konvertierung zwischen T1und gibt T2.)

Auf der anderen Seite if/elsefunktioniert die folgende Version:

T GetT()
{
   if (true) return new T1();
   return new T2();
}

weil T1konvertiert wird Tund so istT2

Manchmal kann es die Zuweisung eines Bool-Werts auf den ersten Blick leichter lesbar machen:

// With
button.IsEnabled = someControl.HasError ? false : true;

// Without
button.IsEnabled = !someControl.HasError;

Wenn ich einen Wert einstelle und weiß, dass dies immer eine Codezeile ist, verwende ich normalerweise den ternären (bedingten) Operator. Wenn sich mein Code und meine Logik in Zukunft möglicherweise ändern, verwende ich ein if / else, da dies für andere Programmierer klarer ist.

Von weiterem Interesse für Sie kann die ?? Betreiber .

Der Vorteil des bedingten Operators besteht darin, dass er ein Operator ist. Mit anderen Worten, es wird ein Wert zurückgegeben. Da ifes sich um eine Anweisung handelt, kann sie keinen Wert zurückgeben.

Ich würde empfehlen, die Verwendung des ternären (? :) Operators auf die einfache Zuweisung einer einzelnen Zeile zu beschränken, wenn / sonst Logik. Etwas ähnlich diesem Muster:

if(<boolCondition>) {
    <variable> = <value>;
}
else {
    <variable> = <anotherValue>;
}

Könnte leicht konvertiert werden zu:

<variable> = <boolCondition> ? <value> : <anotherValue>;

Ich würde es vermeiden, den ternären Operator in Situationen zu verwenden, in denen if / else if / else, verschachtelte if / else oder if / else-Verzweigungslogik erforderlich sind, die zur Auswertung mehrerer Zeilen führt. Das Anwenden des ternären Operators in diesen Situationen würde wahrscheinlich zu unlesbarem, verwirrendem und nicht verwaltbarem Code führen. Hoffe das hilft.

Es gibt einige Leistungsvorteile bei der Verwendung des? Betreiber in z. MS Visual C ++, aber dies ist wirklich eine compilerspezifische Sache. In einigen Fällen kann der Compiler den bedingten Zweig tatsächlich optimieren.

Das Szenario, in dem ich es am häufigsten verwende, betrifft Standardwerte und insbesondere Rückgaben

return someIndex < maxIndex ? someIndex : maxIndex;

Das sind wirklich die einzigen Orte, an denen ich es schön finde, aber für sie tue ich es.

Wenn Sie nach einem Booleschen Wert suchen, scheint dies manchmal eine angemessene Vorgehensweise zu sein:

bool hey = whatever < whatever_else ? true : false;

Weil es so einfach zu lesen und zu verstehen ist, aber diese Idee sollte immer für das Offensichtliche geworfen werden:

bool hey = (whatever < whatever_else);

Wenn Sie mehrere Zweige unter derselben Bedingung benötigen, verwenden Sie ein if:

if (A == 6)
  f(1, 2, 3);
else
  f(4, 5, 6);

Wenn Sie mehrere Zweige mit unterschiedlichen Bedingungen benötigen und die Anzahl der Anweisungen Schneeball schlagen würde, sollten Sie das ternäre verwenden:

f( (A == 6)? 1: 4, (B == 6)? 2: 5, (C == 6)? 3: 6 );

Sie können auch den ternären Operator bei der Initialisierung verwenden.

const int i = (A == 6)? 1 : 4;

Das zu tun mit if ist sehr chaotisch:

int i_temp;
if (A == 6)
   i_temp = 1;
else
   i_temp = 4;
const int i = i_temp;

Sie können die Initialisierung nicht in if / else einfügen, da dies den Bereich ändert. Referenzen und const-Variablen können jedoch nur bei der Initialisierung gebunden werden.

Der ternäre Operator kann in einen r-Wert aufgenommen werden, ein Wenn-Dann-Sonst nicht. Andererseits kann ein Wenn-Dann-Sonst Schleifen und andere Anweisungen ausführen, während der ternäre Operator nur (möglicherweise ungültige) r-Werte ausführen kann.

In einem verwandten Hinweis sind die && und || Operatoren erlauben einige Ausführungsmuster, die mit if-then-else schwieriger zu implementieren sind. Wenn Sie beispielsweise mehrere Funktionen aufrufen müssen und einen Code ausführen möchten, wenn eine davon fehlschlägt, können Sie dies mit dem Operator && tun. Wenn Sie auf diesen Operator verzichten, ist entweder redundanter Code, ein goto oder eine zusätzliche Flag-Variable erforderlich.

Mit C # 7 können Sie die neue Ref-Locals- Funktion verwenden, um die bedingte Zuweisung von Ref-kompatiblen Variablen zu vereinfachen. Jetzt können Sie also nicht nur Folgendes tun:

int i = 0;

T b = default(T), c = default(T);

// initialization of C#7 'ref-local' variable using a conditional r-value⁽¹⁾

ref T a = ref (i == 0 ? ref b : ref c);

... aber auch das extrem wundervolle:

// assignment of l-value⁽²⁾ conditioned by C#7 'ref-locals'

(i == 0 ? ref b : ref c) = a;

Diese Codezeile weist den Wert von aentweder boder zu c, abhängig vom Wert von i.