Trójskładnikowy czy nie trójskładnikowy? [Zamknięte]

Osobiście jestem zwolennikiem operatora trójskładnikowego: ()? :; Zdaję sobie sprawę, że ma swoje miejsce, ale spotkałem wielu programistów, którzy są całkowicie przeciwni jego używaniu, a także takich, którzy używają go zbyt często.

Co o tym myślisz? Jaki interesujący kod widziałeś przy jego użyciu?

Używaj go tylko do prostych wyrażeń :

int a = (b > 10) ? c : d;

Nie łącz ani nie zagnieżdżaj operatorów trójskładnikowych, ponieważ są one trudne do odczytania i mylące:

int a = b > 10 ? c < 20 ? 50 : 80 : e == 2 ? 4 : 8;

Ponadto, używając operatora trójargumentowego, rozważ formatowanie kodu w sposób poprawiający czytelność:

int a = (b > 10) ? some_value                 
                 : another_value;

To sprawia, że ​​debugowanie jest nieco trudniejsze, ponieważ nie można umieścić punktów przerwania w każdym z wyrażeń podrzędnych. Rzadko go używam.

Uwielbiam je, zwłaszcza w językach bezpiecznych dla typów.

Nie rozumiem, jak to:

int count = (condition) ? 1 : 0;

jest trudniejsze niż to:

int count;

if (condition)
{
  count = 1;
}
else
{
  count = 0;
}

Twierdzę, że operatory trójskładnikowe sprawiają, że wszystko jest mniej złożone i bardziej uporządkowane niż alternatywa.

Jestem przykuty - zagnieżdżony, nie tak bardzo.

Zwykle używam ich częściej w C po prostu dlatego, że są instrukcjami if , które mają wartość, więc ograniczają niepotrzebne powtórzenia lub zmienne:

x = (y < 100) ? "dog" :
    (y < 150) ? "cat" :
    (y < 300) ? "bar" : "baz";

zamiast

     if (y < 100) { x = "dog"; }
else if (y < 150) { x = "cat"; }
else if (y < 300) { x = "bar"; }
else              { x = "baz"; }

Uważam, że w takich zadaniach jest mniej do refaktoryzacji i jest jaśniejszy.

Z drugiej strony, kiedy pracuję z rubinem, częściej używam, if...else...endponieważ jest to również wyrażenie.

x =   if (y < 100) then "dog"
    elif (y < 150) then "cat"
    elif (y < 300) then "bar"
    else                "baz"
    end

(Chociaż, co prawda, w przypadku czegoś tak prostego mógłbym i tak użyć operatora trójskładnikowego).

Trójskładnikowy ?: operator tylko funkcjonalny odpowiednik procesowego ifkonstrukcji. Tak długo, jak nie używasz ?:wyrażeń zagnieżdżonych , argumenty za / przeciw reprezentacji funkcjonalnej dowolnej operacji mają tutaj zastosowanie. Ale zagnieżdżanie operacji trójskładnikowych może spowodować, że kod jest wręcz zagmatwany (ćwiczenie dla czytelnika: spróbuj napisać parser, który będzie obsługiwał zagnieżdżone trójskładnikowe warunkowe, a docenisz ich złożoność).

Ale jest wiele sytuacji, w których konserwatywne użycie ?: operatora może spowodować, że kod będzie w rzeczywistości łatwiejszy do odczytania niż w innym przypadku. Na przykład:

int compareTo(Object object) {
    if((isLessThan(object) && reverseOrder) || (isGreaterThan(object) && !reverseOrder)) {
       return 1;
    if((isLessThan(object) && !reverseOrder) || (isGreaterThan(object) && reverseOrder)) {
       return -1;
    else
      return 0;
}

Teraz porównaj to z tym:

int compareTo(Object object) {
    if(isLessThan(object))
        return reverseOrder ? 1 : -1;
    else(isGreaterThan(object))
        return reverseOrder ? -1 : 1;
    else
       return 0;
}

Ponieważ kod jest bardziej zwarty, występuje mniej szumu składniowego, a dzięki rozsądnemu użyciu operatora trójskładnikowego (to jest tylko w odniesieniu do właściwości reverseOrder ), wynik końcowy nie jest szczególnie zwięzły.

Tak naprawdę to kwestia stylu; podświadome zasady, którymi się kieruję, to:

• Oceniaj tylko 1 wyrażenie - tak foo = (bar > baz) ? true : false, ale NIEfoo = (bar > baz && lotto && someArray.Contains(someValue)) ? true : false
• Jeśli używam go do logiki wyświetlania, np <%= (foo) ? "Yes" : "No" %>
• Naprawdę używaj go tylko do przydziału; nigdy nie płynie logika (więc nigdy (foo) ? FooIsTrue(foo) : FooIsALie(foo)) Logika przepływu w trójskładniku sama w sobie jest kłamstwem, zignoruj ​​ten ostatni punkt.

Podoba mi się, ponieważ jest zwięzły i elegancki do prostych operacji przypisania.

Podobnie jak w przypadku wielu pytań opinii, odpowiedź jest nieuchronna: to zależy

Na przykład:

return x ? "Yes" : "No";

Myślę, że jest to dużo bardziej zwięzłe (i szybsze dla mnie do przeanalizowania) niż:

if (x) {
    return "Yes";
} else {
    return "No";
}

Jeśli twoje wyrażenie warunkowe jest złożone, operacja trójskładnikowa nie jest dobrym wyborem. Coś jak:

x && y && z >= 10 && s.Length == 0 || !foo

nie jest dobrym kandydatem na operatora trójskładnikowego.

Nawiasem mówiąc, jeśli jesteś programistą C, GCC ma w rzeczywistości rozszerzenie, które pozwala wykluczyć część trójskładnikową jeśli-prawda, na przykład:

/* 'y' is a char * */
const char *x = y ? : "Not set";

Który będzie ustawiony xna yzałożeniu ynie jest NULL. Dobry towar.

Moim zdaniem sensowne jest używanie operatora trójskładnikowego tylko w przypadkach, gdy potrzebne jest wyrażenie.

W innych przypadkach wydaje się, że operator trójskładnikowy zmniejsza przejrzystość.

Miarą złożoności cyklicznej jest użycie ifinstrukcji lub operatora trójskładnikowego. Tak więc, biorąc pod uwagę tę miarę, odpowiedź brzmi nie , złożoność byłaby dokładnie taka sama jak poprzednio.

Dzięki innym miarom, takim jak czytelność, łatwość konserwacji i SUCHA (nie powtarzaj się), każdy wybór może okazać się lepszy od drugiego.

Używam go dość często w miejscach, w których jestem ograniczony do pracy w konstruktorze - na przykład w nowych konstrukcjach .NET 3.5 LINQ to XML - do definiowania wartości domyślnych, gdy opcjonalny parametr ma wartość null.

Wymyślony przykład:

var e = new XElement("Something",
    param == null ? new XElement("Value", "Default")
                  : new XElement("Value", param.ToString())
);

lub (dzięki asterite)

var e = new XElement("Something",
    new XElement("Value",
        param == null ? "Default"
                      : param.ToString()
    )
);

Niezależnie od tego, czy używasz operatora trójskładnikowego, czy nie, ważne jest, aby upewnić się, że kod jest czytelny. Każda konstrukcja może stać się nieczytelna.

Używam operatora trójskładnikowego, gdzie tylko mogę, chyba że sprawia, że ​​kod jest wyjątkowo trudny do odczytania, ale wtedy zwykle jest to tylko wskazówka, że ​​mój kod może wymagać trochę refaktoryzacji.

Zawsze mnie zastanawia, jak niektórzy ludzie myślą, że operator trójskładnikowy jest „ukrytą” funkcją lub jest nieco tajemniczy. To jedna z pierwszych rzeczy, których nauczyłem się, kiedy zaczynam programować w C i nie sądzę, żeby to w ogóle zmniejszało czytelność. To naturalna część języka.

Zgadzam się z jmulder: nie należy go używać zamiast a if, ale ma swoje miejsce na wyrażenie zwrotne lub wewnątrz wyrażenia:

echo "Result: " + n + " meter" + (n != 1 ? "s" : "");
return a == null ? "null" : a;

To pierwsze jest tylko przykładem i należy zastosować lepszą internacjonalizację i lokalizację liczby mnogiej!

Jeśli używasz operatora trójskładnikowego do prostego przypisania warunkowego, myślę, że jest w porządku. Widziałem to (ab) używane do kontrolowania przepływu programu nawet bez dokonywania przypisań i myślę, że należy tego unikać. W takich przypadkach użyj instrukcji if.

(Hack dnia)

#define IF(x) x ?
#define ELSE :

Następnie możesz zrobić if-then-else jako wyrażenie:

int b = IF(condition1)    res1
        ELSE IF(condition2)  res2
        ELSE IF(conditions3) res3
        ELSE res4;

Myślę, że operator trójskładnikowy powinien być używany w razie potrzeby. Jest to oczywiście bardzo subiektywny wybór, ale uważam, że proste wyrażenie (szczególnie jako wyrażenie zwrotne) jest znacznie jaśniejsze niż pełny test. Przykład w C / C ++:

return (a>0)?a:0;

W porównaniu do:

if(a>0) return a;
else return 0;

Masz również przypadek, w którym rozwiązanie znajduje się między operatorem trójskładnikowym a utworzeniem funkcji. Na przykład w Pythonie:

l = [ i if i > 0 else 0 for i in lst ]

Alternatywą jest:

def cap(value):
    if value > 0:
        return value
    return 0
l = [ cap(i) for i in lst ]

Wystarczy, że w Pythonie (na przykład) taki idiom można było zobaczyć regularnie:

l = [ ((i>0 and [i]) or [0])[0] for i in lst ]

ta linia wykorzystuje właściwości operatorów logicznych w Pythonie: są one leniwe i zwraca ostatnią obliczoną wartość, jeśli jest równa stanowi ostatecznemu.

Widziałem takie bestie jak (w rzeczywistości było znacznie gorzej, ponieważ była to data Validate i sprawdzałem również miesiąc i dzień, ale nie przeszkadzało mi to zapamiętać całość):

isLeapYear =
    ((yyyy % 400) == 0)
    ? 1
    : ((yyyy % 100) == 0)
        ? 0
        : ((yyyy % 4) == 0)
            ? 1
            : 0;

gdzie, po prostu, seria instrukcji „jeśli” byłaby lepsza (chociaż ta jest wciąż lepsza niż wersja makro, którą kiedyś widziałem).

Nie przeszkadzają mi takie małe rzeczy, jak:

reportedAge = (isFemale && (Age >= 21)) ? 21 + (Age - 21) / 3 : Age;

lub nawet nieco skomplikowane rzeczy, takie jak:

printf ("Deleted %d file%s\n", n, (n == 1) ? "" : "s");

Lubię używać operatora w kodzie debugowania do drukowania wartości błędów, więc nie muszę ich cały czas sprawdzać. Zwykle robię to w celu debugowania wydruków, które nie pozostaną po zakończeniu programowania.

int result = do_something();
if( result != 0 )
{
  debug_printf("Error while doing something, code %x (%s)\n", result,
                result == 7 ? "ERROR_YES" :
                result == 8 ? "ERROR_NO" :
                result == 9 ? "ERROR_FILE_NOT_FOUND" :
                "Unknown");
}

Prawie nigdy nie używam operatora trójskładnikowego, ponieważ zawsze to robię używam, zawsze sprawia, że ​​myślę o wiele więcej niż później, kiedy próbuję go utrzymać.

Lubię unikać gadatliwości, ale kiedy znacznie ułatwi to odczytanie kodu, zdecyduję się na szczegółowość.

Rozważać:

String name = firstName;

if (middleName != null) {
    name += " " + middleName;
}

name += " " + lastName;

To trochę rozwlekłe, ale uważam, że jest o wiele bardziej czytelne niż:

String name = firstName + (middleName == null ? "" : " " + middleName)
    + " " + lastName;

Lub:

String name = firstName;
name += (middleName == null ? "" : " " + middleName);
name += " " + lastName;

Po prostu wydaje się, że kompresuje zbyt dużo informacji w zbyt małej przestrzeni, nie wyjaśniając, co się dzieje. Za każdym razem, gdy widziałem używany operator trójskładnikowy, zawsze znajdowałem alternatywę, która wydawała się znacznie łatwiejsza do odczytania ... z drugiej strony jest to niezwykle subiektywna opinia, więc jeśli ty i twoi koledzy uznacie trójskładnik za bardzo czytelny, idźcie na to.

Lubię ich. Nie wiem dlaczego, ale czuję się bardzo fajnie, kiedy używam tego trójskładnikowego wyrażenia.

Operatorów trójskładnikowych traktuję bardzo podobnie jak GOTO. Mają swoje miejsce, ale są czymś, czego zwykle należy unikać, aby kod był łatwiejszy do zrozumienia.

Cóż, składnia tego jest okropna. Uważam, że funkcjonalne instrukcje if są bardzo przydatne i często sprawiają, że kod jest bardziej czytelny.

Sugerowałbym zrobienie makra, aby było bardziej czytelne, ale jestem pewien, że ktoś może wymyślić okropny przypadek skrajny (jak zawsze jest w C ++).

Zwykle używam go do takich rzeczy:

before:

if(isheader)
    drawtext(x, y, WHITE, string);
else
    drawtext(x, y, BLUE, string);

after:

    drawtext(x, y, isheader == true ? WHITE : BLUE, string);

Jak zauważyli inni, są dobre na krótkie, proste warunki. Szczególnie lubię je za wartości domyślne (takie jak || i lub użycie w JavaScript i Pythonie), np

int repCount = pRepCountIn ? *pRepCountIn : defaultRepCount;

Innym typowym zastosowaniem jest zainicjowanie odwołania w C ++. Ponieważ odwołania muszą być zadeklarowane i zainicjowane w tej samej instrukcji, nie można użyć instrukcji if .

SomeType& ref = pInput ? *pInput : somethingElse;

Podoba mi się specjalny przypadek Groovy'ego z operatorem trójskładnikowym, zwanym operatorem Elvisa:?:

expr ?: default

Ten kod oblicza wyrażenie, jeśli nie jest null, i domyślnie, jeśli tak jest. Technicznie nie jest to tak naprawdę operator trójskładnikowy, ale zdecydowanie jest z nim powiązany i oszczędza dużo czasu / pisania.

Niedawno widziałem odmianę operatorów trójskładnikowych (cóż, w pewnym sensie), które sprawiają, że standardowy wariant "()?:" Wydaje się być wzorem jasności:

var Result = [CaseIfFalse, CaseIfTrue][(boolean expression)]

lub, żeby podać bardziej konkretny przykład:

var Name = ['Jane', 'John'][Gender == 'm'];

Pamiętaj, że to JavaScript, więc takie rzeczy mogą nie być możliwe w innych językach (na szczęście).

Tylko kiedy:

$var = (simple > test ? simple_result_1 : simple_result_2);

KISS .

W prostych przypadkach lubię go używać. W rzeczywistości znacznie łatwiej jest czytać / kodować, na przykład jako parametry funkcji lub podobnych rzeczy. Również, aby uniknąć nowej linii, którą lubię trzymać ze wszystkimi moimi if / else.

Zagnieżdżanie go byłoby wielkim nie-nie w mojej książce.

Tak więc, wznawiając, dla pojedynczego if / else użyję operatora trójskładnikowego. W innych przypadkach zwykłe if / else if / else (lub switch).

W przypadku prostych zadań, takich jak przypisywanie różnych wartości w zależności od warunku, są świetne. Nie użyłbym ich jednak, gdy istnieją dłuższe wyrażenia w zależności od warunku.

Jeśli ty i twoi współpracownicy rozumiecie, co robią, i nie są tworzeni w dużych grupach, myślę, że dzięki temu kod jest mniej złożony i łatwiejszy do odczytania, ponieważ jest po prostu mniej kodu.

Myślę, że operatory trójskładnikowe sprawiają, że kod jest trudniejszy do zrozumienia tylko wtedy, gdy masz więcej niż trzy lub foyr w jednym wierszu. Większość ludzi nie pamięta, że ​​mają właściwe pierwszeństwo, a kiedy masz ich stos, czytanie kodu staje się koszmarem.

Jak mówi wiele odpowiedzi, to zależy . Uważam, że jeśli porównanie trójskładnikowe nie jest widoczne w szybkim skanowaniu kodu, to nie powinno być używane.

Na marginesie mogę również zauważyć, że samo jego istnienie jest właściwie trochę anomalią, ponieważ w C testowanie porównawcze jest stwierdzeniem. W Icon The ifkonstrukt (jak większość ikon) jest rzeczywiście wyrazem. Możesz więc robić takie rzeczy, jak:

x[if y > 5 then 5 else y] := "Y"

... który uważam za znacznie bardziej czytelny niż trójskładnikowy operator porównania. :-)

Niedawno dyskutowano o możliwości dodania ?:operatora do Icon, ale kilka osób słusznie wskazało, że absolutnie nie ma takiej potrzeby ze względu na sposóbif działania .

Co oznacza, że ​​gdybyś mógł to zrobić w C (lub w jakimkolwiek innym języku, który ma operator trójskładnikowy), to w rzeczywistości nie potrzebowałbyś operatora trójskładnikowego.