Kısa devre değerlendirmesi kötü uygulama mı?

Bir süredir tanıdığım ama hiç düşünmediğim bir şey, çoğu dilde, operatörlere sırasına göre if ifadesinde öncelik vermenin mümkün olduğudur. Bunu genellikle boş referans istisnalarını önlemenin bir yolu olarak kullanırım, örneğin:

if (smartphone != null && smartphone.GetSignal() > 50)
{
   // Do stuff
}

Bu durumda, kod ilk önce nesnenin boş olmadığını kontrol eder ve daha sonra var olduğunu bilerek bu nesneyi kullanır. Dil akıllıdır, çünkü eğer ilk ifade yanlışsa o zaman ikinci ifadeyi değerlendirmenin bile bir anlamı olmadığını bilir ve böylece boş bir referans istisnası asla atılmaz. Bu andve oroperatörler için aynı şekilde çalışır .

Java, C #, C ++, Python ve Matlab: Bu, bir endeksin bir dizinin sınırları içerisinde olup olmadığını kontrol etmek gibi başka durumlarda da yararlı olabilir ve böyle bir teknik benim bilgime göre çeşitli dillerde yapılabilir.

Sorum şu: Bu tür bir kod kötü uygulamaların bir temsili midir? Bu kötü uygulama bazı gizli teknik sorunlardan mı kaynaklanıyor (bu sonuçta bir hataya neden olabilir) veya diğer programcılar için okunabilirlik sorununa mı yol açıyor? Kafa karıştırıcı olabilir mi?

Hayır, bu kötü bir uygulama değil. Koşulsuzluğun kısa devre edilmesine dayanmak, yaygın olarak kabul edilen, faydalı bir tekniktir - bu davranışı garanti eden bir dil kullandığınız sürece (modern dillerin büyük çoğunluğunu içerir).

Kod örneğiniz oldukça açıktır ve gerçekten, bu genellikle yazmanın en iyi yoludur. Alternatifler (iç içe ififadeler gibi ) daha karmaşık, daha karmaşık ve bu nedenle anlaşılması daha zor olabilir.

Birkaç uyarılar:

Karmaşıklık ve okunabilirlik konusunda sağduyulu kullanın

Aşağıdakiler iyi bir fikir değil:

if ((text_string != null && replace(text_string,"$")) || (text_string = get_new_string()) != null)

Kodunuzdaki çizgileri azaltmanın birçok "akıllı" yolu gibi, bu tekniğe aşırı güvenmek anlaşılması zor, hataya açık kodla sonuçlanabilir.

Hataları işlemeniz gerekirse, genellikle daha iyi bir yol vardır

Akıllı telefonunuzun boş olması normal bir program durumunda olduğu sürece, örneğiniz iyi. Ancak, bu bir hataysa, daha akıllı bir hata işleme eklemelisiniz.

Aynı durumda tekrarlanan kontrollerden kaçının

Neil'in belirttiği gibi, farklı şartlarda aynı değişkenin tekrarlanan kontrolleri büyük olasılıkla bir tasarım hatasının kanıtıdır. Kodunuzda, çalıştırılmaması gereken 10 farklı ifade varsa smartphone, nulldeğişkeni her seferinde kontrol etmekten daha iyi bir yol olup olmadığını düşünün.

Bu gerçekten kısa devre yapmakla ilgili değil; tekrarlayan kodun daha genel bir sorunu. Ancak, bahsetmeye değer, çünkü example deyiminiz gibi birçok tekrarlanan ifadeye sahip olan kodu görmek oldukça yaygındır.

Diyelim ki, C tarzı bir dili kullanıyorsunuz ve hayır &&ile eşdeğer kodu yapmak için gerekli ve sorunuzdaki gibi.

Kodunuz:

if(smartphone != null)
{
  if(smartphone.GetSignal() > 50)
  {
    // Do stuff
  }
}

Bu model çok fazla ortaya çıkacaktı.

Şimdi bizim varsayımsal dilin 2.0 versiyonunun tanıttığını hayal edin &&. Ne kadar havalı olduğunu düşünürsün!

&&Yukarıdaki örneğimin yaptığını yapmanın tanınmış, deyimsel yoludur. Bunu kullanmak kötü bir uygulama değildir, aslında yukarıdaki gibi durumlarda kullanmamak kötü bir uygulamadır: Böyle bir dilde deneyimli bir kodlayıcı else, normal şekilde bir şey yapmamak için nerede ya da başka bir neden olduğunu merak ediyor olabilir .

Dil akıllıdır, çünkü eğer ilk ifade yanlışsa o zaman ikinci ifadeyi değerlendirmenin bile bir anlamı olmadığını bilir ve böylece boş bir referans istisnası asla atılmaz.

Hayır, sen ilk deyimi yanlış olsaydı o zaman bile ikinci ifadeyi değerlendiren bir nokta olduğunu bildikleri için, akıllı. Dil bir taş kutusu kadar aptal ve yapmanı söylediğini yaptın. (John McCarthy daha akıllıydı ve kısa devre değerlendirmesinin dillerin sahip olması için yararlı bir şey olacağını fark etti).

Akıllı olmanızla dilin akıllı olmanız arasındaki fark önemlidir, çünkü iyi ve kötü uygulamalar genellikle gerektiği kadar akıllı olmanıza rağmen daha fazla akıllı olmanıza neden olmaz.

Düşünmek:

if(smartphone != null && smartphone.GetSignal() > ((range = (range != null ? range : GetRange()) != null && range.Valid ? range.MinSignal : 50)

Bu, kodunuzu kontrol etmek için genişletir range. Eğer rangeboş ise o zaman bir GetRange()başarısızlıkla sonuçlanmaya çalışsa da onu boş bırakmaya çalışır range. Bundan sonra aralık null değilse ve o Validzaman MinSignalözelliği kullanılır, aksi takdirde varsayılan 50olarak kullanılır.

Bu da buna bağlı &&, ancak tek bir satıra koymak muhtemelen çok zekice (% 100 haklı olduğumdan emin değilim ve iki kez kontrol edemem çünkü bu gerçek benim amacımı gösteriyor).

&&Buradaki sorun bu değil , ama bir ifadeye çok şey koymak için kullanma yeteneği (iyi bir şey) gereksiz yere anlaşılması zor ifadeler yazma yeteneğimizi arttırıyor (kötü bir şey).

Ayrıca:

if(smartphone != null && (smartphone.GetSignal() == 2 || smartphone.GetSignal() == 5 || smartphone.GetSignal() == 8 || smartPhone.GetSignal() == 34))
{
  // do something
}

Burada, kullanımını &&belirli değerler için bir kontrol ile birleştiriyorum . Bu, telefon sinyalleri için gerçekçi değildir, diğer durumlarda da ortaya çıkmaktadır. İşte, yeterince zeki olmamamın bir örneği. Eğer aşağıdakileri yaparsam:

if(smartphone != null)
{
  switch (smartphone.GetSignal())
  {
    case 2: case 5: case 8: case 34:
      // Do something
      break;
  }
}

Hem okunabilirlikten, hem de performanstan büyük olasılıkla kazanmış olurdum (çoklu aramalar GetSignal()muhtemelen optimize edilemeyecekti).

Burada yine sorun, &&o belirli çekiciyi alıp, diğer her şeyi çivi olarak görmek kadar değildir; kullanmamak, kullanmaktan daha iyi bir şey yapmama izin veriyor.

En iyi uygulamalardan uzaklaşan son bir vaka:

if(a && b)
{
  //do something
}

Nazaran:

if(a & b)
{
  //do something
}

Sonuncuyu niçin tercih edebileceğimize dair klasik argüman , doğru bolup olmadığının değerlendirilmesinde bazı yan etkilerin olduğudur a. Buna katılmıyorum: Bu yan etki çok önemliyse, ayrı bir kod satırında olmasını sağlayın.

Bununla birlikte, verimlilik açısından ikisinden birinin daha iyi olması muhtemeldir. Birincisi, değerlendirmek biçin ne kadar zaman harcayacağımızdan kurtarabilecek olan, daha az kod (hiç bir kod yolunda değerlendirmemek) yürütecektir b.

Birincisi yine de bir tane daha dalı var. Şunu varsayımsal C tarzı dilimizde no &&:

if(a)
{
  if(b)
  {
    // Do something
  }
}

Bu ekstra ifbizim kullanımımızda gizli &&, ama hala orada. Dolayısıyla, şube tahmininin gerçekleştiği ve potansiyel olarak şube yanlış tahmininin olduğu bir durum söz konusudur.

Bu nedenle, if(a & b)kod bazı durumlarda daha verimli olabilir.

Burada, if(a && b)bunun hala başlamak için en iyi uygulama yaklaşımı olduğunu söyleyebilirim : Daha yaygın, bazı durumlarda geçerli olan tek ( yanlış bise hata olur a) ve olmadığıdan daha hızlı. Bununla if(a & b)birlikte, bazı durumlarda üzerinde genellikle yararlı bir optimizasyon olduğuna dikkat etmek önemlidir.

Bunu daha da ileriye götürebilirsiniz ve bazı dillerde işleri yapmanın deyimsel yolu: koşullu ifadelerin dışında kısa devre değerlemesi de kullanabilirsiniz ve bunlar koşullu ifadenin bir biçimi olurlar. Örneğin, Perl'de, işlevlerin başarısızlık konusunda yanlış bir şey (ve başarıda hakikaten bir şeyler) ve benzeri şeyler döndürmesi aptalcadır.

open($handle, "<", "filename.txt") or die "Couldn't open file!";

deyimseldir. openbaşarı üzerine sıfır olmayan bir şey döndürür (böylece asla gerçekleşmeyen diebölüm or), ancak başarısızlıkta tanımsız kalır ve sonra gerçekleşen çağrı die(Perl'in bir istisna yaratma yolu) olur.

Bu herkesin yaptığı dillerde iyidir.

Dan1111'in cevabına genel olarak katılıyorum, ancak bunu kapsamadığı özel bir durum var: smartphoneeşzamanlı olarak kullanıldığı durum . Bu senaryoda, bu tür bir patern, böcek bulmak için iyi bilinen bir kaynaktır.

Sorun, kısa devre değerlendirmesinin atomik olmamasıdır. Kişisel iplik kontrol edebilirsiniz smartphoneis null, başka bir iş parçacığı gelip onu geçersiz ve ardından iplik derhal çalışır edebilir GetSignal()ve havaya uçuruyor.

Ama tabii ki, sadece yıldız hizalamak ve ne zaman lifler zamanlama olduğunu yapar sadece hakkı.

Bu nedenle, bu tür bir kod çok yaygın ve faydalı olsa da, bu kötü hatayı tam olarak önleyebilmeniz için bu uyarıyı bilmek önemlidir.

İlk önce bir durumu kontrol etmek istediğim ve yalnızca ilk koşul başarılı olursa ikinci bir koşulu kontrol etmek istediğim birçok durum var. Bazen sadece verimlilik için (eğer birincisi başarısız olursa, ikinci durumu kontrol etmenin bir anlamı olmadığı için), bazen aksi halde programım çökeceği için (önce NULL için kontrolünüz), bazen aksi halde sonuçlar korkunç olacaktır. (EĞER (bir belge yazdırmak istiyorum) VE (bir belge basma başarısız oldu)) SONRA bir hata mesajı görüntüler - belgeyi yazdırmak istemez ve belgede belge yazdırmak istemiyorsanız, yazdırmanın başarısız olup olmadığını kontrol edin ilk yer!

Dolayısıyla, mantıksal ifadelerin garantili kısa devre değerlendirmesine çok büyük bir ihtiyaç vardı. Önemli bir ağrı olan Pascal'da (garanti edilmeyen kısa devre değerlendirmesi vardı) yoktu; İlk önce Ada ve C’de gördüm.

Bunun gerçekten "kötü bir uygulama" olduğunu düşünüyorsanız, lütfen orta derecede karmaşık bir kod parçasını alın, kısa devre değerlendirmesi yapılmadan düzgün çalışacak şekilde yeniden yazın ve geri dönüp bize nasıl hoşunuza gittiğini söyleyin. Bu, nefes almanın karbondioksit ürettiği ve nefes almanın kötü bir uygulama olup olmadığını sorması gibi bir şey. Birkaç dakika boyunca onsuz deneyin.

Diğer cevaplarda bahsedilmeyen bir husus: bazen bu kontrollerin yapılması, Null Object tasarım modeline olası bir yeniden yapılandırma hakkında ipucu verebilir . Örneğin:

if (currentUser && currentUser.isAdministrator()) 
  doSomething();

Sadece olması için basitleştirilmiş olabilir:

if (currentUser.isAdministrator())
  doSomething ();

Eğer currentUserbir geri dönüş uygulaması ile bazı 'anonim kullanıcı' veya 'boş user' varsayılan ayarı kullanıcı oturum değilse.

Her zaman bir kod kokusu değil, dikkate alınması gereken bir şey.

Ben popüler olamayacağım ve Evet diyorum, bu kötü bir uygulamadır. Eğer kodunuzun işlevselliği, şartlı mantığı uygulamak için ona güveniyorsa.

yani

 if(quickLogicA && slowLogicB) {doSomething();}

iyidir ama

if(logicA && doSomething()) {andAlsoDoSomethingElse();}

kötü ve elbette kimse kabul edemez mi ?!

if(doSomething() || somethingElseIfItFailed() && anotherThingIfEitherWorked() & andAlwaysThisThing())
{/* do nothing */}

Sebep:

Her iki taraf da yalnızca mantığı gerçekleştirmemek yerine değerlendirilirse, kod hatalarınız. Bunun bir sorun olmadığı, 've' işlecinin c # ile tanımlandığı, yani anlamın açık olduğu iddia edildi. Ancak bunun doğru olmadığını iddia ediyorum.

Sebep 1. Tarihsel

Temel olarak, kodunuzda işlevsellik sağlamak için bir derleyici optimizasyonuna (başlangıçta ne kastedildiği gibi) güveniyorsunuz.

C # dilinde olmasına rağmen, dil özellikleri booleni garanti ediyor 've' operatörü kısa devre yapıyor. Bu, tüm diller ve derleyiciler için geçerli değildir.

wikipeda çeşitli dilleri ve kısa devre almak onların listeler http://en.wikipedia.org/wiki/Short-circuit_evaluation birçok yaklaşımlar vardır gibi. Ve bir kaç ekstra sorun da buraya girmiyorum.

Özellikle, FORTRAN, Pascal ve Delphi bu davranışı değiştiren derleyici bayraklarına sahiptir.

Bu nedenle: Kodun serbest bırakılması için derlendiğinde çalışıp hata ayıklama için veya alternatif bir derleyici vb.

Sebep 2. Dil farklılıkları

Vikipedi'den görebileceğiniz gibi, boolean operatörlerinin onu nasıl idare etmeleri gerektiğini belirleseler bile, tüm diller kısa devrelere aynı yaklaşımı benimsemez.

Özellikle VB.Net'in 've' operatörü kısa devre yapmaz ve TSQL'in bazı özellikleri vardır.

Modern bir 'çözümün' javascript, regex, xpath vb. Gibi bir dizi dili içermesi muhtemel olduğu göz önüne alındığında, kod işlevselliğinizi netleştirirken bunu göz önünde bulundurmalısınız.

Sebep 3. Dil içindeki farklılıklar

Örneğin VB'nin satır içi, eğer kendi durumundan farklı davranıyorsa. Yine modern uygulamalarda kodunuz, örneğin arkasındaki kod ve bir satır içi web formu arasında hareket edebilir, anlamdaki farklılıkların farkında olmalısınız.

Sebep 4. Özel bir işlevin parametresini kontrol etmek için boş örneğiniz

Bu bir çok iyi bir örnek. Bu, herkesin yaptığı bir şeydir, ama düşündüğünüz zaman aslında kötü bir uygulamadır.

Kod türünüzü önemli ölçüde azalttığı için bu tür bir çek görmek çok yaygındır. Bir kimsenin kod incelemesinde ortaya çıkacağından şüpheliyim. (ve tabii ki yorum ve puanlardan popüler olduğunu görebilirsiniz!)

Ancak, birden fazla nedenden ötürü en iyi uygulamayı yapamamaktadır!

1. Onun çok sayıda kaynaklardan berrak, o en iyi uygulama kullanmadan önce geçerliliği için parametrelerini kontrol etmek ve geçersiz oldukları takdirde bir istisna etmektir. Kod pasajınız çevre kodunu göstermiyor ancak muhtemelen aşağıdaki gibi bir şey yapıyor olmalısınız:

   if (smartphone == null)
   {
       //throw an exception
   }
   // perform functionality

2. Sen bir işlev aradığınız içinde koşullu deyimi. İşlevinizin adı yalnızca bir değeri hesapladığını ima etse de, yan etkileri gizleyebilir. Örneğin

   Smartphone.GetSignal() { this.signal++; return this.signal; }
   
   else if (smartphone.GetSignal() < 1)
   {
       // Do stuff 
   }
   else if (smartphone.GetSignal() < 2)
   {
       // Do stuff 
   }

   En iyi uygulama önerebilir:

   var s = smartphone.GetSignal();
   if(s < 50)
   {
       //do something
   }

Bu en iyi uygulamaları kodunuza uygularsanız, gizli koşullu kullanımı kullanarak daha kısa kod alma fırsatınızın kaybolduğunu görebilirsiniz. En iyi yöntem, akıllı telefonun boş olduğu durumda işlemek için bir şeyler yapmaktır .

Bunun diğer yaygın kullanımlar için de geçerli olduğunu göreceksiniz. Ayrıca şunu da hatırlamamız gerekiyor:

satır içi koşullamalar

var s = smartphone!=null ? smartphone.GetSignal() : 0;

ve boş birleşme

var s = smartphoneConnectionStatus ?? "No Connection";

daha net bir şekilde benzer kısa kod uzunluğu işlevsellik sağlayan

tüm puanlarımı desteklemek için sayısız bağlantı:

https://stackoverflow.com/questions/1158614/what-is-the-best-practice-in-case-one-argument-is-null

Yapıcı parametre doğrulama C # - En iyi yöntemler

Null beklemiyorsa null olup olmadığını kontrol etmeli mi?

https://msdn.microsoft.com/en-us/library/seyhszts%28v=vs.110%29.aspx

https://stackoverflow.com/questions/1445867/why-would-a-language-not-use-short-circuit-evaluation

http://orcharddojo.net/orchard-resources/Library/DevelopmentGuidelines/BestPractices/CSharp

kısa devreyi etkileyen derleyici bayrağı örnekleri:

Fortran: "sce | nosce Varsayılan olarak, derleyici XL Fortran kurallarını kullanarak seçilen mantıksal ifadelerde kısa devre değerlendirmesini gerçekleştirir. Sce belirtilmesi, derleyicinin XL Fortran olmayan kuralları kullanmasına izin verir. "Varsayılan, buruntur."

Pascal: "B - Kısa devre değerlendirmesini kontrol eden bir bayrak direktifi. Kısa devre değerlendirmesi hakkında daha fazla bilgi için bkz. Kullanım Kılavuzunda belgelenmiştir). "

Delphi: "Delphi varsayılan olarak kısa devre değerlendirmesini destekler. {$ BOOLEVAL OFF} derleyici yönergesi kullanılarak kapatılabilir."