Üçlü mü üçlü mi değil mi? [kapalı]

Ben şahsen üçlü operatörün savunucusuyum: ()? :; Onun yeri olduğunu fark ettim, ama onu her zaman kullanmaya tamamen karşı olan ve bazılarını çok sık kullanan birçok programcıya rastladım.

Bununla ilgili duygularınız neler? Bunu kullanırken hangi ilginç kodu gördünüz?

Yalnızca basit ifadeler için kullanın :

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

Üçlü operatörleri okumak ve kafa karıştırmak zor olduğu için zincirlemeyin veya yuvalamayın :

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

Ayrıca, üçlü operatör kullanırken, kodu okunabilirliği artıracak şekilde biçimlendirmeyi düşünün:

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

Alt ifadelerin her birine kesme noktası yerleştiremediğiniz için hata ayıklamayı biraz daha zorlaştırır. Nadiren kullanıyorum.

Onları, özellikle güvenli yazılan dillerde seviyorum.

Bunun nasıl olduğunu göremiyorum:

int count = (condition) ? 1 : 0;

bundan daha zor:

int count;

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

Düzenle -

Üçlü operatörlerin her şeyi alternatiften daha az karmaşık ve temiz hale getirdiğini iddia ediyorum.

Zincirleme Ben iyiyim - iç içe, çok değil.

Onları sadece C / b kullanmak daha eğilimindedir b / c değeri olan bir if ifadesi, bu yüzden gereksiz tekrarlama veya değişkenleri keser:

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

ziyade

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

Bunun gibi ödevlerde, refactor için daha az ve daha net buluyorum.

Öte yandan yakutta çalışırken, daha çok kullanacağım if...else...endçünkü bu da bir ifade.

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

(itiraf etmek gerekirse, bu kadar basit bir şey için, yine de üçlü operatörü kullanabilirim).

Üçlü ?:operatör yalnızca prosedürel ifyapının işlevsel bir eşdeğeridir . İç içe ?:ifadeler kullanmadığınız sürece, burada herhangi bir işlemin işlevsel temsili için / ona karşı olan argümanlar geçerlidir. Ancak yuvalama üçlü işlemleri düpedüz kafa karıştırıcı bir kodla sonuçlanabilir (okuyucu için egzersiz: iç içe üçlü koşullarını işleyecek bir ayrıştırıcı yazmayı deneyin ve karmaşıklıklarını takdir edersiniz).

Ancak ?:operatörün muhafazakar kullanımının, okunması gerçekten daha kolay olan kodla sonuçlanabileceği birçok durum vardır . Örneğin:

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

Şimdi bununla karşılaştırın:

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

Kod daha kompakt olduğundan daha az sözdizimsel gürültü vardır ve üçlü operatör (bu sadece reverseOrder özelliğiyle bağlantılı olarak) akıllıca kullanılarak nihai sonuç özellikle düşük değildir.

Bu gerçekten bir tarz meselesi; uyguladığım bilinçaltı kurallar:

• Yalnızca 1 ifadeyi değerlendirin - yani foo = (bar > baz) ? true : false, DEĞİLfoo = (bar > baz && lotto && someArray.Contains(someValue)) ? true : false
• Görüntü mantığı için kullanıyorsanız, örn. <%= (foo) ? "Yes" : "No" %>
• Sadece gerçekten atama için kullanın; asla akma mantığı (bu yüzden asla (foo) ? FooIsTrue(foo) : FooIsALie(foo)) Üçlü akış mantığının kendisi bir yalandır, son noktayı görmezden gelin.

Seviyorum çünkü basit görevlendirme işlemleri için özlü ve zarif.

Pek çok fikir soruların gibi cevap kaçınılmaz olduğunu: duruma göre değişir

Gibi bir şey için:

return x ? "Yes" : "No";

Bence bu çok daha özlü (ve benim için ayrıştırmam daha hızlı):

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

Koşullu ifadeniz karmaşıksa, üçlü işlem iyi bir seçim değildir. Gibi bir şey:

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

üçlü operatör için iyi bir aday değil.

Bir kenara, eğer bir C programcısıysanız, GCC aslında üçlünün if-true kısmını hariç tutmanıza izin veren bir uzantıya sahiptir :

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

Set hangi xiçin yvarsayarak ydeğildir NULL. İyi şeyler.

Aklımda, üçlü ifadeyi yalnızca bir ifadenin gerekli olduğu durumlarda kullanmak mantıklı.

Diğer durumlarda, üçlü operatör netliği azaltır gibi görünüyor.

Siklomatik karmaşıklığın ölçüsü ile , ififadelerin veya üçlü operatörün kullanımı eşdeğerdir. Yani bu önlemle, cevap hayır , karmaşıklık eskisi gibi olacaktı.

Okunabilirlik, bakım kolaylığı ve KURU (Tekrarlama-Kendiniz) gibi diğer önlemlerle, her iki seçim de diğerinden daha iyi olabilir.

İsteğe bağlı bir parametre null olduğunda varsayılan değerleri tanımlamak için bir yapıcıda (örneğin, yeni .NET 3.5 LINQ to XML yapıları) çalışmak zorunda olduğum yerlerde sık sık kullanıyorum.

Onaylanmış örnek:

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

veya (teşekkürler asterit)

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

Üçlü işleci kullansanız da kullanmasanız da, kodunuzun okunabilir olduğundan emin olmanız önemlidir. Herhangi bir yapı okunamaz hale getirilebilir.

Üçlü operatörü, kodun okunmasını son derece zorlaştırmadıkça, yapabildiğim her yerde kullanıyorum, ancak bu genellikle kodumun biraz yeniden düzenleme yapabileceğinin bir göstergesi.

Her zaman bazı kişilerin üçlü operatörün "gizli" bir özellik olduğunu ya da biraz gizemli olduğunu düşündüğü her zaman beni şaşırttı. C programlamaya başladığımda öğrendiğim ilk şeylerden biri ve okunabilirliği hiç azaltmadığını sanmıyorum. Bu dilin doğal bir parçası.

Jmulder'a katılıyorum: a yerine kullanılmamalıdır if, ancak dönüş ifadesi veya bir ifadenin içinde yeri vardır:

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

İlki sadece bir örnektir, daha iyi bir i18n çoğul desteği kullanılmalıdır!

(Günün kesmek)

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

Daha sonra if-then-else ifadesini yapabilirsiniz:

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

Üçlü operatörü basit bir koşullu atama için kullanıyorsanız, bence iyi. Bir program yapmadan program akışını kontrol etmek için kullanıldığını gördüm ve bundan kaçınılması gerektiğini düşünüyorum. Bu durumlarda bir if ifadesi kullanın.

Üçlü operatörün gerektiğinde kullanılması gerektiğini düşünüyorum. Açıkçası çok öznel bir seçim, ama basit bir ifadenin (özellikle bir dönüş ifadesi olarak) tam bir testten çok daha açık olduğunu düşünüyorum. C / C ++ ile örnek:

return (a>0)?a:0;

Nazaran:

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

Ayrıca çözümün üçlü operatör ile bir işlev oluşturma arasında olduğu bir durum da vardır. Örneğin Python'da:

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

Alternatif:

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

Python'da (örnek olarak) böyle bir deyimin düzenli olarak görülebilmesi için yeterli olması gerekir:

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

bu satır Python'daki mantıksal işleçlerin özelliklerini kullanır: tembeldirler ve son duruma eşitse hesaplanan son değeri döndürür.

Onları seviyorum. Nedenini bilmiyorum ama üçlü ifadeyi kullandığımda kendimi çok iyi hissediyorum.

Böyle canavarlar gördüm (aslındaValidDate olduğundan çok daha kötüydü ve ay ve gün de kontrol ettim, ama her şeyi hatırlamaya çalışırken rahatsız edemedim):

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

açıkça, bir dizi if-ifadesi daha iyi olurdu (her ne kadar bu bir zamanlar gördüğüm makro versiyondan daha iyi olsa da).

Bunun gibi küçük şeyler için umursamıyorum:

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

hatta biraz zor şeyler gibi:

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

Bunun sözdizimi korkunç. Fonksiyonel ifs çok yararlı buluyorum ve genellikle kodu daha okunabilir hale getirir.

Daha okunabilir hale getirmek için bir makro yapmayı öneriyorum, ama eminim birisi (her zaman CPP ile olduğu gibi) korkunç bir uç dava ile gelebilir.

Hata değerlerini yazdırmak için hata ayıklama kodunda operatörü kullanmayı seviyorum, böylece onları her zaman aramak zorunda kalmam. Genellikle bunu, geliştirmeyi tamamladıktan sonra kalmayacak hata ayıklama baskıları için yaparım.

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

Üçlü operatörü neredeyse hiç kullanmıyorum, çünkü ne zaman kullansam, onu sürdürmeye çalıştığımda her zaman daha sonradan daha fazla düşünmemi sağlıyor.

Ayrıntıdan kaçınmayı seviyorum, ancak kodu almak çok daha kolay hale geldiğinde, ayrıntı için gideceğim.

Düşünmek:

String name = firstName;

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

name += " " + lastName;

Şimdi, bu biraz ayrıntılı, ama ben daha çok daha okunabilir buluyorum:

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

veya:

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

Neler olduğunu netleştirmeden çok fazla bilgiyi çok az alana sıkıştırıyor gibi görünüyor. Üçlü operatörün her kullanılışını gördüğümde, her zaman okunması daha kolay görünen bir alternatif buldum ... o zaman, bu son derece öznel bir fikir, bu yüzden siz ve meslektaşlarınız üçlü çok okunabilir bulursanız, bunun için gidin.

Yalnızca:

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

ÖPÜCÜK.

Genellikle böyle şeylerde kullanın:

before:

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

after:

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

Diğerlerinin de belirttiği gibi, kısa basit koşullar için iyidirler. Özellikle varsayılanlar için onları seviyorum (tür gibi || ve veya javascript ve python kullanımı gibi ), örneğin

int repCount = pRepCountIn ? *pRepCountIn : defaultRepCount;

Başka bir yaygın kullanım, C ++ 'da bir başvuru başlatmaktır. Referansların aynı ifadede bildirilmesi ve başlatılması gerektiğinden, bir if ifadesini kullanamazsınız.

SomeType& ref = pInput ? *pInput : somethingElse;

Üçlü operatörlere GOTO'ya çok benziyorum. Yerlerine sahipler, ancak kodun daha kolay anlaşılmasını sağlamak için genellikle kaçınmanız gereken bir şeydir.

Son zamanlarda, standart "()?:" Varyantının bir netlik paragonu gibi göründüğü üçlü operatörler (iyi, bir çeşit) üzerinde bir varyasyon gördüm:

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

veya daha somut bir örnek vermek gerekirse:

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

Dikkat edin, bu Javascript, bu yüzden diğer dillerde (şükür ki) böyle şeyler mümkün olmayabilir.

Basit olsaydı, kullanmayı seviyorum. Aslında, örneğin işlevler veya bunun gibi şeyler için parametreler olarak okunması / kodlanması çok daha kolaydır. Ayrıca yeni satırı önlemek için tüm if / else ile tutmak istiyorum.

Neseting benim kitabımda büyük bir NO-NO olurdu.

Yani, devam edersek, tek bir if / else için üçlü operatörü kullanacağım. Diğer durumlarda normal if / else if / else (veya switch)

Groovy'un Elvis operatörü olarak adlandırılan üçlü operatör özel vakasını seviyorum:?

expr ?: default

Bu kod, boş değilse ifade olarak ve varsayılan olarak varsayılan olarak değerlendirilir. Teknik olarak gerçekten üçlü bir operatör değil, ama kesinlikle onunla ilgili ve çok fazla zaman / yazma tasarrufu sağlıyor.

Bir koşula bağlı olarak farklı bir değer atamak gibi basit görevler için mükemmeldirler. Tho durumuna bağlı olarak daha uzun ifadeler olduğunda onları kullanmazdım.

Pek çok cevap söyledi, duruma göre . Üçlü karşılaştırma kodu hızlı bir taramada görünmüyorsa, o zaman kullanılmamalıdır.

Bir yan sorun olarak, C'de karşılaştırma testinin bir ifade olması nedeniyle varlığının aslında biraz anomol olduğunu da belirtebilirim. Icon'da, ifyapı (Icon'ın çoğu gibi) aslında bir ifadedir. Böylece aşağıdakileri yapabilirsiniz:

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

... bir üçlü karşılaştırma operatöründen çok daha okunabilir buldum. :-)

Son zamanlarda ?:operatörü Icon'a ekleme olasılığı hakkında bir tartışma vardı , ancak birkaç kişi yoldan dolayı kesinlikle gerekmediğini doğru bir şekilde belirtti.if .

Bu, eğer C (ya da ternery operatörüne sahip diğer dillerden herhangi birinde) yapabilseydiniz, aslında, ternery operatörüne hiç ihtiyacınız olmayacağı anlamına gelir.

Siz ve çalışma arkadaşlarınız ne yaptıklarını anlarlar ve büyük gruplar halinde oluşturulmazlarsa, kodu daha az karmaşık ve okunması daha kolay hale getirir, çünkü sadece daha az kod vardır.

Üçlü operatörlerin kodu zor anlaşılır hale getirdiğini düşündüğüm tek zaman, 3 veya 4'ten fazla satır olduğunda. Çoğu insan doğru temelli bir öncelik olduğunu hatırlamıyor ve bir yığınınız olduğunda kodu okumayı kabus haline getiriyor.