Ara ver ve devam et kötü programlama uygulamaları?

Patronum şüphesiz kötü programcıların breakve continuedöngüler içinde kullandıklarından bahseder .

Onları her zaman kullanırım çünkü anlamlıdırlar; size ilhamını göstereyim:

function verify(object) {
    if (object->value < 0) return false;
    if (object->value > object->max_value) return false;
    if (object->name == "") return false;
    ...
}

Buradaki nokta, önce işlevin koşulların doğru olduğunu kontrol etmesi, ardından gerçek işlevselliği yürütmesidir. IMO aynı döngüler için de geçerlidir:

while (primary_condition) {
    if (loop_count > 1000) break;
    if (time_exect > 3600) break;
    if (this->data == "undefined") continue;
    if (this->skip == true) continue;
    ...
}

Bunun okunmayı ve hata ayıklamayı kolaylaştıracağını düşünüyorum; ama ayrıca bir dezavantaj göremiyorum.

Bir bloğun başında kullanıldığında, ilk kontroller yapıldıktan sonra ön koşullar gibi davranırlar, bu yüzden iyidir.

Bloğun ortasında kullanıldığında, bazı kodlar varsa, gizli tuzaklar gibi davranırlar, bu yüzden kötüdür.

Donald Knuth'un 1974 tarihli Yapısal Programlama bölümünü okuyarak go to, yapısal olarak arzu edilen çeşitli kullanımlarını tartıştığı İfadelere bakabilirsiniz. Bunlar, eşdeğer breakve continueifadeleri içerir ( go toiçerisindeki kullanımların çoğu, daha sınırlı yapılar halinde geliştirilmiştir). Patronunuz Knuth'a kötü bir programcı diyecek tür mü?

(Verilen örnekler beni ilgilendirir. Tipik olarak breakve continueherhangi bir kod parçasından tek bir girişi ve bir çıkışını seven ve bu tür bir kişi birden fazla returnifadeye bayılan insanlar tarafından beğenilmez .)

Kötü olduklarına inanmıyorum. Kötü oldukları fikri, yapılandırılmış programlama günlerinden geliyor. Bir işlevin tek bir giriş noktasına ve tek bir çıkış noktasına sahip olması gerektiği, yani returnişlev başına yalnızca bir tane olması gerektiği görüşü ile ilgilidir .

İşleviniz uzunsa ve birden fazla iç içe döngü varsa, bu bir anlam ifade eder. Bununla birlikte, işlevleriniz kısa olmalı ve döngüler ve bedenlerini kendi işlevlerinin kısa işlevlerine sarmalısınız. Genel olarak, bir fonksiyonu tek bir çıkış noktasına zorlamak çok karmaşık mantığa neden olabilir.

Eğer işleviniz çok kısaysa, tek bir ilmekiniz varsa veya en kötü iki iç içe ilmeğiniz varsa ve ilmek gövdesi çok kısaysa, o zaman a breakveya a'nın ne yaptığı çok açıktır continue. Birden fazla returnifadenin ne yaptığı da açıktır .

Bu konular Robert C. Martin tarafından "Temiz Kod" te ve Martin Fowler tarafından "Yeniden Düzenleme" de ele alınmıştır.

Kötü programcılar mutlak konuşurlar (tıpkı Sith gibi). İyi programcılar mümkün olan en açık çözümü kullanırlar ( tüm diğer şeyler eşitdir ).

Ara ve sık kullanmaya devam etmek, kodun takip edilmesini zorlaştırır. Fakat eğer bunları değiştirmek, kodu takip etmeyi zorlaştırırsa, bu kötü bir değişiklik.

Verdiğiniz örnek kesinlikle ara vermenin ve devam etmenin daha zarif bir şeyle değiştirilmesi gereken bir durumdur.

Çoğu insan bunun kötü bir fikir olduğunu düşünür çünkü davranış kolayca tahmin edilebilir değildir. Eğer kodu okuyorsanız ve while(x < 1000){}x> = 1000 olana kadar çalışacağını varsayarsınız ... Fakat ortada bir mola varsa, o zaman bu doğru olmaz, bu yüzden gerçekten kendinize güvenemezsiniz. döngü ...

Sonuçta sorunsuz: İnsanların GOTO sevmiyorum aynı neden olabilir iyi kullanılabilir, ama aynı zamanda kod bölümden bölüme rastgele atlar godawful spagetti kod, yol açabilir.

Kendim için, birden fazla şartı bozan bir döngü yapacak olsaydım, ayrılmam gerektiğinde while(x){}X'i yanlışa çevirirdim. Nihai sonuç aynı olacaktır ve kodu okuyan herkes X'in değerini değiştiren şeylere daha yakından bakmayı bilirdi.

Evet, break ifadesi olmadan programları yeniden yazabilirsiniz (veya aynı şeyi yapan döngülerin ortasından döndürür). Ancak, her ikisinin de programı anlamayı zorlaştırdığı ek değişkenler ve / veya kod çoğaltması yapmanız gerekebilir. Pascal (programlama dili) özellikle acemi programcılar için bu nedenle çok kötüydü. Patronun temel olarak Pascal'ın kontrol yapılarında program yapmanı istiyor. Linus Torvalds ayakkabının içinde olsaydı, muhtemelen patronuna orta parmağını gösterirdi!

Kosaraju’nun 1973’e dayanan ve 1974’ten bu yana Knuth’un (daha fazla) ünlü makalesinde değinilen kontrol yapıları hiyerarşisi olarak adlandırılan bir bilgisayar bilimi sonucu var. .) ne S. Rao Kosaraju 1973 yılında kanıtladı o derinlik çok düzeyli sonları olan tüm programları yeniden yazmak mümkün değildir olmasıdır n daha mola derinliği az olan programlara n ekstra değişkenleri tanıtan olmadan. Diyelim ki bu sadece teorik bir sonuç. (Sadece bir kaç ekstra değişken ekleyelim mi ?! Kesinlikle patronunuzu memnun etmek için bunu yapabilirsiniz ...)

Yazılım mühendisliği perspektifinden çok daha önemli olan, Eric S. Roberts'ın Döngü Çıkışları ve Yapısal Programlama: Tartışmayı Yeniden Açma başlıklı 1995 tarihli makalesidir ( http://cs.stanford.edu/people/eroberts/papers/SIGCSE- 1995 / LoopExits.pdf ). Roberts ondan önce başkaları tarafından yürütülen deneysel çalışmaları özetlemektedir. Örneğin, CS101 tipi bir grup öğrenciden bir dizide sıralı bir arama uygulayan bir fonksiyon için kod yazması istendiğinde, çalışmanın yazarı, bir ayrılma / geri dönüş / goto kullanan kişi hakkında eleman bulunduğunda sıralı arama döngüsü:

Henüz yanlış bir çözüm üreten [bu stili] kullanarak bir programı deneyen tek bir kişi bulamadım.

Roberts ayrıca şunu söylüyor:

Sorunu açık bir şekilde kullanmadan çözmeye çalışan öğrenciler, for döngüsünden geri dönüşü çok daha az başardı: Bu stratejiyi deneyen 42 öğrenciden sadece 7'si doğru çözümler üretmeyi başardı. Bu rakam% 20'den az bir başarı oranını temsil ediyor.

Evet, CS101 öğrencilerinden daha deneyimli olabilirsiniz, ancak break deyimini kullanmadan (veya döngülerin ortasından eşit olarak geri döndüğünüzde), sonunda mantıklı bir şekilde yapılandırılmış olarak ekstra mantık açısından yeterince kıllı olan kod yazacaksınız. Patronunuzun kodlama stilini izlemeye çalışırken muhtemelen kendiniz birinin kullandığı değişkenler ve kod çoğaltması buna mantık hataları koyacaktır.

Burada Roberts’ın kağıdının ortalama bir programlayıcı için çok daha erişilebilir olduğunu söyleyeceğim, bu yüzden Knuth’lardan daha iyi bir ilk okuma. Aynı zamanda daha kısa ve daha dar bir konuyu kapsıyor. Muhtemelen CS tipinden ziyade yönetim olsa bile bunu patronunuza önerebilirsiniz.

Bu kötü uygulamaların ikisini de kullanmayı düşünmüyorum, ancak aynı döngü içinde onları çok fazla kullanmak döngüde kullanılan mantığı yeniden düşünmeyi sağlamalıdır. Onları dikkatli kullanın.

Verdiğiniz örneğin ara vermesine veya devam etmesine gerek yok:

while (primary-condition AND
       loop-count <= 1000 AND
       time-exec <= 3600) {
   when (data != "undefined" AND
           NOT skip)
      do-something-useful;
   }

Örnekteki 4 satırla ilgili 'sorunum' hepsi aynı seviyede olmaları, ancak farklı şeyler yapmalarıdır: Bazıları ara, bazıları devam eder ... Her satırı okumalısınız.

İç içe yaklaşımımda, ne kadar derine giderseniz, kod o kadar “kullanışlı” olur.

Ancak, derinlerde bir döngüyü durdurmak için bir neden bulursanız (birincil koşul dışında), bir mola veya geri dönüşün kullanımı olur. Üst seviye bir durumda test edilecek ekstra bir bayrak kullanılmasını tercih ederim. Mola / geri dönüş daha doğrudandır; başka bir değişkeni ayarlamaktan daha iyi bir niyet olduğunu belirtir.

"Kötülük", onları nasıl kullandığınıza bağlıdır. SADECE döngü yapılarında molaları kullanıyorum, SADECE bir algoritmanın yeniden yapılandırılması ile kurtarılamayan çevrimleri kurtardığı zaman. Örneğin, belirli bir özellik için true değerine sahip bir öğeyi arayan bir koleksiyonda gezinme. Bilmeniz gereken tek şey, öğelerden birinin bu özelliği true olarak ayarlamış olması durumunda, bu sonucu elde ettiğinizde, bir döngüyü uygun şekilde sonlandırmak iyidir.

Bir mola kullanılması, kodun okunmasını, çalıştırılmasının daha kısa sürmesini ya da işlemlerde belirgin bir şekilde tasarruf edilmesini kısaltıyorsa, bunları kullanmamak en iyisidir. Beni takip eden herkesin koduma kolayca bakabildiğinden ve ne olup bittiğini anlayabilmesinden emin olmak için mümkün olduğunda "en düşük ortak payda" ya kodlama eğilimindeyim (bu konuda her zaman başarılı olamam). Kırılmalar bunu azaltıyor çünkü tek giriş / çıkış noktaları oluşturuyorlar. Kötüye kullanıldıkları için, "tomo" ifadesi gibi davranırlar.

Kesinlikle hayır ... Evet, kullanımı gotokötü, çünkü programınızın yapısını bozuyor ve kontrol akışını anlamak çok zor.

Ancak bu günlerde olduğu gibi breakve continuekesinlikle kesinlikle gerekli olan ifadelerin kullanılması ve hiç de kötü programlama uygulaması olarak kabul edilmemektedir.

Ve ayrıca o kadar zor değil kullanımında kontrol akışını anlamak breakve continue. Gibi yapılarda açıklamada kesinlikle gereklidir.switchbreak

Temel kavram, programınızı anlamsal olarak analiz edebilmekten geliyor. Tek bir girişiniz ve tek bir çıkışınız varsa, olası durumları belirtmek için gereken matematik, çatal yollarını yönetmeniz gerekenden çok daha kolaydır.

Kısmen, bu zorluk, kodunuz hakkında kavramsal olarak akıl yürütmeyi başarabiliyor.

Açıkçası, ikinci kodun açık değil. Ne yapıyor? Devam ediyor mu 'devam ediyor mu', yoksa döngünün yanında mı? Hiç bir fikrim yok. En azından ilk örneğiniz açık.

İkinci kod parçacığını değiştiririm

while (primary_condition && (loop_count <= 1000 && time_exect <= 3600)) {
    if (this->data != "undefined" && this->skip != true) {
        ..
    }
}

Herhangi bir açıklık sebebi için değil - aslında bunun daha kolay olduğunu ve birinin neler olduğunu anlaması için daha kolay olduğunu düşünüyorum. Genel olarak konuşursanız, döngülerinizin koşullarının tamamen vücutta yayılmamış bu döngü koşullarında yer alması gerekir. Ancak okunabilirliğe yardımcı olabilecek breakve continueyardımcı olabileceği bazı durumlar vardır . ekleyebileceğimden breakdaha fazla moreso continue: D

Patronuna katılmıyorum. Kullanılacak breakve continuekullanılacak uygun yerler var . Aslında uygulamaların ve istisnaların ele alınmasının modern programlama dillerine getirilmesinin nedeni, her sorunu sadece kullanarak çözememenizdir structured techniques.

Bir yandan notta, burada dini bir tartışma başlatmak istemiyorum, ancak kodunuzu bu şekilde daha okunaklı olacak şekilde yeniden yapılandırabilirsiniz:

while (primary_condition) {
    if (loop_count > 1000) || (time_exect > 3600) {
        break;
    } else if ( ( this->data != "undefined") && ( !this->skip ) ) {
       ... // where the real work of the loop happens
    }
}

Başka bir yandan notta

Ben ( flag == true )şartlı kullanımlardan kişisel olarak hoşlanmam çünkü değişken zaten bir boole ise, boolenin değeri istediğiniz cevaba sahipse, olması gereken ek bir karşılaştırma sunuyorsunuz - tabii ki derleyicinizin alacağından emin değilseniz bu ekstra karşılaştırmayı uzağa optimize edin.

Patronunla aynı fikirdeyim. Kötüdürler çünkü yüksek döngüsel karmaşıklığa sahip yöntemler üretirler. Bu yöntemlerin okunması ve test edilmesi zor. Neyse ki kolay bir çözüm var. Döngü gövdesini “Devam Et” in “dönüş” olduğu ayrı bir yönteme çıkarın. "Geri dönüş" daha iyidir çünkü "geri döndükten" sonra biter - yerel devlet için endişelenmez.

"Break" için, "break" yerine "return" yerine döngünün kendisini ayrı bir yönteme çıkarın.

Ayıklanan yöntemler çok sayıda argüman gerektiriyorsa, bu bir sınıfı çıkarmanın bir göstergesidir - ya bir bağlam nesnesine toplayın.

Bence sadece çoklu döngüler içinde derinlere yuvalanmış bir problem. Hangi döngüye girdiğini bilmek zor. Ayrıca devam etmenin takip edilmesi zor olabilir, ama asıl acının molalardan kaynaklandığını düşünüyorum - mantığın izlenmesi zor olabilir.

Aşağıdaki örnekte olduğu gibi gizlenmiş olarak kullanılmadıkları sürece:

do
{
      if (foo)
      {
             /*** code ***/
             break;
      }

      if (bar)
      {
             /*** code ***/
             break;
      }
} while (0);

Onlarla iyiyim. (Üretim kodunda görülen örnek, meh)

Bu tarzların hiçbirini sevmiyorum. İşte tercih edeceğim şey:

function verify(object)
{
    if not (object->value < 0) 
       and not(object->value > object->max_value)
       and not(object->name == "") 
       {
         do somethign important
       }
    else return false; //probably not necessary since this function doesn't even seem to be defined to return anything...?
}

Gerçekten returnbir işlevi iptal etmek için kullanmayı sevmiyorum . Suistimali gibi geliyor return.

breakAyrıca kullanmak okumak her zaman net değildir.

Daha iyisi olabilir:

notdone := primarycondition    
while (notDone)
{
    if (loop_count > 1000) or (time_exect > 3600)
    {
       notDone := false; 
    }
    else
    { 
        skipCurrentIteration := (this->data == "undefined") or (this->skip == true) 

        if not skipCurrentIteration
        {
           do something
        } 
        ...
    }
}

daha az yuvalanma ve karmaşık koşullar değişkenlere yeniden yansıtılır (gerçek bir programda daha iyi adlara sahip olmanız gerekir).

(Yukarıdaki kodların tümü sahte koddur)

Hayır. Sorunu çözmenin bir yolu ve bunu çözmenin başka yolları da var.

Pek çok güncel ana dil (Java, .NET (C # + VB), PHP, kendi dilini yaz) döngüleri atlamak için "break" ve "devam" ı kullanır. Her ikisi de "yapılandırılmış goto (lar)" cümleleri.

Onlarsız:

String myKey = "mars";

int i = 0; bool found = false;
while ((i < MyList.Count) && (not found)) {
  found = (MyList[i].key == myKey);
  i++;   
}
if (found)
  ShowMessage("Key is " + i.toString());
else
  ShowMessage("Not found.");

Onlarla:

String myKey = "mars";

for (i = 0; i < MyList.Count; i++) {
  if (MyList[i].key == myKey)
    break;
}
ShowMessage("Key is " + i.toString());

"Break" ve "devam" kodunun daha kısa olduğunu ve genellikle "cümle" için "veya" foreach "cümle olarak" döndüğünü "unutmayın.

Her iki durumda da kodlama tarzı bir konudur. Bunları kullanmamayı tercih ediyorum , çünkü ayrıntılı stil kodu daha fazla kontrol etmeme izin veriyor.

Aslında, bu cümleleri kullanmanın zorunlu olduğu bazı projelerde çalışıyorum.

Bazı geliştiriciler, gerekli olmadıklarını düşünebilirler, ancak varsayımsal, eğer onları çıkarmak zorunda kalırsak, "süre" yi ve "süre" yi ("kadar" tekrarlayın ");

Sonuç Onları kullanmamayı tercih etsem bile, bunun kötü bir programlama uygulaması olmadığını düşünüyorum.

Buna karşı continueve breakilke olarak değilim , ancak çok daha iyi bir şeyle değiştirilebilecek çok düşük seviyeli yapılar olduklarını düşünüyorum.

Burada bir örnek olarak C # kullanıyorum, bir koleksiyon üzerinde yineleme yapmak istediğimizi düşünün, ancak yalnızca bazı yordamları yerine getiren öğeleri istiyoruz ve maksimum 100 yinelemeden fazlasını yapmak istemiyoruz.

for (var i = 0; i < collection.Count; i++)
{
    if (!Predicate(item)) continue;
    if (i >= 100) break; // at first I used a > here which is a bug. another good thing about the more declarative style!

    DoStuff(item);
}

Bu NEDEN temiz görünüyor. Bunu anlamak çok zor değil. Bence daha açıklayıcı olmaktan çok şey kazanabileceğini düşünüyorum. Aşağıdakilerle karşılaştırın:

foreach (var item in collection.Where(Predicate).Take(100))
    DoStuff(item);

Belki de Nerede ve Al çağrıları bu yöntemde olmamalıdır. Belki de bu filtreleme, koleksiyonun bu metoda geçirilmesinden ÖNCE yapılmalıdır. Her neyse, düşük seviyeli nesnelerden uzaklaşarak ve gerçek iş mantığına odaklanarak daha çok GERÇEKLEŞTİRDİĞİMİZ ile netleştik. Kodumuzu iyi tasarım uygulamalarına daha çok bağlı kalabilen uyumlu modüllere ayırmak daha kolay hale geliyor. üzerinde.

Kodun bazı kısımlarında hala düşük seviyeli şeyler var olacak, ancak bunu mümkün olduğunca gizlemek istiyoruz, çünkü bunun yerine iş sorunları hakkında akıl yürütmek için kullanabileceğimiz zihinsel enerjiyi alır.

Kod Tamamlama , gotorutin veya döngüden döndürme ve kullanma hakkında hoş bir bölüme sahiptir .

Genelde kötü bir uygulama değil. breakya da continuetam olarak ne olacağını söyleyin. Ve buna katılıyorum.

Steve McConnell (Code Complete'in yazarı), çeşitli gotoifadeleri kullanmanın avantajlarını göstermek için neredeyse aynı örnekleri kullanır .

Bununla birlikte aşırı kullanım breakveya continuekarmaşık ve sürdürülemez bir yazılıma yol açabilir.