Korzyści z używania operatora warunkowego?: (Trójskładnikowego)

Jakie są zalety i wady operatora?: W porównaniu ze standardową instrukcją if-else. Te oczywiste to:

Warunkowe?: Operator

• Krótsze i bardziej zwięzłe w przypadku bezpośrednich porównań wartości i przypisań
• Nie wydaje się być tak elastyczny jak konstrukcja if / else

Standardowe Jeśli / Jeszcze

• Może być stosowany w większej liczbie sytuacji (takich jak wywołania funkcji)
• Często są niepotrzebnie długie

Czytelność wydaje się różna dla każdego w zależności od stwierdzenia. Przez chwilę po pierwszym kontakcie z operatorem?: Zajęło mi trochę czasu, zanim dokładnie przeanalizowałem, jak to działa. Czy poleciłbyś używanie go wszędzie tam, gdzie to możliwe, czy trzymanie się if / else, biorąc pod uwagę, że pracuję z wieloma nie-programistami?

Zasadniczo zalecałbym używanie go tylko wtedy, gdy wynikowe stwierdzenie jest wyjątkowo krótkie i przedstawia znaczny wzrost zwięzłości w stosunku do odpowiednika if / else bez utraty czytelności.

Dobry przykład:

int result = Check() ? 1 : 0;

Zły przykład:

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

Jest to prawie omówione w innych odpowiedziach, ale „to wyrażenie” nie wyjaśnia, dlaczego jest to tak przydatne ...

W językach takich jak C ++ i C # można za ich pomocą definiować lokalne pola tylko do odczytu (w treści metody). Nie jest to możliwe w przypadku konwencjonalnej instrukcji jeśli / to, ponieważ wartość pola tylko do odczytu musi zostać przypisana w ramach tej pojedynczej instrukcji:

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

to nie to samo co:

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

W podobny sposób możesz osadzić trzeciorzędne wyrażenie w innym kodzie. Oprócz tego, że kod źródłowy jest bardziej zwarty (aw niektórych przypadkach bardziej czytelny), może również sprawić, że wygenerowany kod maszynowy będzie bardziej zwarty i wydajny:

MoveCar((shiftKeyDown) ? 10 : 1);

... może generować mniej kodu niż konieczność dwukrotnego wywoływania tej samej metody:

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

Oczywiście jest to również wygodniejsza i bardziej zwięzła forma (mniej pisania, mniej powtórzeń i może zmniejszyć ryzyko błędów, jeśli musisz zduplikować fragmenty kodu w instrukcji if / else). W czystych „typowych wzorcach”, takich jak ten:

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

... jest po prostu szybszy do czytania / analizowania / rozumienia (kiedy już się do tego przyzwyczaisz) niż rozwlekły odpowiednik if / else, więc może pomóc ci w szybszym "grokowaniu" kodu.

Oczywiście tylko dlatego, że jest użyteczny , nie oznacza, że ​​najlepiej jest go używać w każdym przypadku. Radziłbym używać go tylko do krótkich fragmentów kodu, których znaczenie jest jasne (lub bardziej zrozumiałe), używając ?:- jeśli użyjesz go w bardziej złożonym kodzie lub zagnieżdżasz w sobie operatory trójskładnikowe, może to bardzo utrudnić odczytanie kodu .

Zwykle wybieram operator trójskładnikowy, gdy w przeciwnym razie miałbym dużo zduplikowanego kodu.

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

W przypadku operatora trójskładnikowego można to osiągnąć w następujący sposób.

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

Uważam to za szczególnie pomocne podczas tworzenia stron internetowych, jeśli chcę ustawić zmienną na wartość wysłaną w żądaniu, jeśli jest zdefiniowana, lub na jakąś wartość domyślną, jeśli nie jest.

Naprawdę fajne użycie to:

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

Operator warunkowy świetnie sprawdza się w krótkich warunkach, takich jak ten:

varA = boolB ? valC : valD;

Używam go od czasu do czasu, ponieważ napisanie czegoś w ten sposób zajmuje mniej czasu ... niestety to rozgałęzienie może czasami zostać pominięte przez innego programistę przeglądającego Twój kod. Poza tym kod nie jest zwykle taki krótki, więc zwykle pomagam w czytelności, umieszczając znak? i: w oddzielnych wierszach, na przykład:

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

Jednak dużą zaletą używania bloków if / else (i dlaczego je preferuję) jest to, że łatwiej jest wejść później i dodać dodatkową logikę do gałęzi,

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

lub dodaj kolejny warunek:

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

Ostatecznie chodzi więc o wygodę dla Ciebie teraz (krótszą w użyciu:?) Vs. wygodę dla Ciebie (i innych) później. To kwestia oceny ... ale podobnie jak w przypadku wszystkich innych kwestii związanych z formatowaniem kodu, jedyną prawdziwą zasadą jest spójność i wizualna uprzejmość dla tych, którzy muszą utrzymywać (lub oceniać!) Twój kod.

(cały kod skompilowany na oko)

Jedną rzeczą do rozpoznania podczas używania operatora trójskładnikowego jest to, że jest to wyrażenie, a nie instrukcja.

W językach funkcjonalnych, takich jak schemat, rozróżnienie nie istnieje:

(jeśli (> ab) ab)

Warunkowe?: Operator „Nie wydaje się być tak elastyczny jak konstrukcja if / else”

W językach funkcjonalnych tak jest.

Podczas programowania w językach imperatywnych stosuję operator trójskładnikowy w sytuacjach, w których zwykle używałbym wyrażeń (przypisanie, instrukcje warunkowe itp.).

Chociaż powyższe odpowiedzi są ważne i zgadzam się, że czytelność jest ważna, należy wziąć pod uwagę 2 dalsze kwestie:

1. W języku C # 6 można mieć metody zawierające wyrażenia.

To sprawia, że ​​użycie trójskładnika jest szczególnie zwięzłe:

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

2. Zachowanie różni się w przypadku niejawnej konwersji typów.

Jeśli masz typów T1i T2które mogą być zarówno niejawnie konwertowane do T, a następnie poniżej robi nie praca:

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

(ponieważ kompilator próbuje określić typ wyrażenia trójskładnikowego i nie ma konwersji między T1a T2).

Z drugiej strony if/elsedziała poniższa wersja:

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

ponieważ T1jest konwertowany Ti tak jestT2

Czasami może to ułatwić odczytanie przypisania wartości bool na pierwszy rzut oka:

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

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

Jeśli ustawiam wartość i wiem, że zawsze będzie to jeden wiersz kodu, zwykle używam operatora trójargumentowego (warunkowego). Jeśli jest szansa, że ​​mój kod i logika zmienią się w przyszłości, używam if / else, ponieważ jest to bardziej zrozumiałe dla innych programistów.

Może Cię zainteresować ?? operator .

Zaletą operatora warunkowego jest to, że jest operatorem. Innymi słowy, zwraca wartość. Ponieważ ifjest instrukcją, nie może zwrócić wartości.

Zalecałbym ograniczenie używania operatora trójargumentowego (? :) do prostego przypisania pojedynczego wiersza w logice if / else. Coś przypominającego ten wzór:

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

Można go łatwo przekonwertować na:

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

Unikałbym używania operatora trójskładnikowego w sytuacjach, które wymagają if / else if / else, zagnieżdżonej logiki if / else lub if / else branch, która skutkuje obliczeniem wielu wierszy. Zastosowanie operatora trójargumentowego w takich sytuacjach prawdopodobnie spowodowałoby nieczytelny, zagmatwany i niemożliwy do zarządzania kod. Mam nadzieję że to pomoże.

Korzystanie z funkcji? operator w np. MS Visual C ++, ale jest to naprawdę rzecz specyficzna dla kompilatora. W niektórych przypadkach kompilator może faktycznie zoptymalizować gałąź warunkową.

Scenariusz, w którym najczęściej go używam, dotyczy domyślnych wartości, a zwłaszcza zwrotów

return someIndex < maxIndex ? someIndex : maxIndex;

To naprawdę jedyne miejsca, które uważam za miłe, ale dla nich tak.

Chociaż jeśli szukasz wartości logicznej, czasami może to wyglądać na właściwe:

bool hey = whatever < whatever_else ? true : false;

Ponieważ jest tak łatwy do odczytania i zrozumienia, ale ten pomysł zawsze powinien być rzucany na rzecz bardziej oczywistych:

bool hey = (whatever < whatever_else);

Jeśli potrzebujesz wielu oddziałów w tym samym stanie, użyj if:

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

Jeśli potrzebujesz wielu gałęzi z różnymi warunkami, to jeśli liczba instrukcji zmieni się w lawinę, będziesz chciał użyć trójskładnika:

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

Możesz także użyć operatora trójskładnikowego podczas inicjalizacji.

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

Robienie tego z if jest bardzo niechlujne:

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

Nie możesz umieścić inicjalizacji wewnątrz if / else, ponieważ zmienia to zakres. Ale odwołania i zmienne const mogą być powiązane tylko podczas inicjalizacji.

Operator trójskładnikowy może być zawarty w wartości r, podczas gdy jeśli-to-jeszcze nie może; z drugiej strony if-then-else może wykonywać pętle i inne instrukcje, podczas gdy operator trójskładnikowy może wykonywać tylko (prawdopodobnie void) wartości r.

W podobnej notatce && i || operatory zezwalają na niektóre wzorce wykonywania, które są trudniejsze do zaimplementowania za pomocą if-then-else. Na przykład, jeśli ktoś ma kilka funkcji do wywołania i chce wykonać fragment kodu, jeśli którakolwiek z nich zawiedzie, można to łatwo zrobić za pomocą operatora &&. Zrobienie tego bez tego operatora będzie wymagało nadmiarowego kodu, goto lub dodatkowej zmiennej flagowej.

W języku C # 7 możesz użyć nowej funkcji odwołań lokalnych, aby uprościć warunkowe przypisanie zmiennych zgodnych z ref. Więc teraz nie tylko możesz:

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);

... ale także niezwykle cudowne:

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

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

Że linia kodu przypisuje wartość ado jednej blub c, w zależności od wartości i.