For döngüsünde break kullanmak kötü bir uygulama mı? [kapalı]

Bir döngü içinde breakifade kullanmak kötü bir uygulama mı?for

Diyelim ki bir dizide bir değer arıyorum. Bir for döngüsü içinde ve değer bulunduğunda, break;for döngüsünden çıkmak için karşılaştırın.

Bu kötü bir uygulama mı? Kullanılan alternatifi gördüm: bir değişken tanımlayın vFoundve değer bulunduğunda bunu doğru olarak ayarlayın vFoundve forifade koşulunu kontrol edin . Ama sadece bu amaç için yeni bir değişken yaratmak gerekli mi?

Normal bir C veya C ++ for döngüsü bağlamında soruyorum.

Not: MISRA kodlama yönergeleri , ara kullanılmaması gerektiğini belirtir .

Burada pek çok cevap var, ancak bundan bahsedildiğini henüz görmedim:

Düzenli, kolay okunabilir döngüler yazarsanız, bir for döngüsü kullanmakla breakveya continuebir for döngüsü içinde ilişkili "tehlikelerin" çoğu reddedilir. Döngünüzün gövdesi birkaç ekran uzunluğunu kapsıyorsa ve birden çok iç içe geçmiş alt bloğa sahipse, evet, aradan sonra bazı kodların çalıştırılmayacağını kolayca unutabilirsiniz. Bununla birlikte, döngü kısa ve öz ise, break ifadesinin amacı açık olmalıdır.

Bir döngü çok büyürse, bunun yerine döngü içinde bir veya daha fazla iyi adlandırılmış işlev çağrısı kullanın. Bunu yapmaktan kaçınmanın tek gerçek nedeni, darboğazları işlemektir.

Hayır, mola doğru çözümdür.

Bir boole değişkeninin eklenmesi, kodun okunmasını zorlaştırır ve olası bir hata kaynağı ekler.

İçlerinde 'kırılma' ifadeleri bulunan her tür profesyonel kodu bulabilirsiniz. Bunu gerektiğinde kullanmak tamamen mantıklı. Sizin durumunuzda bu seçenek, döngüden çıkmak amacıyla ayrı bir değişken oluşturmaktan daha iyidir.

Bir döngüde olduğu breakkadar kullanmak da gayet iyi.continuefor

Kodu basitleştirir ve okunabilirliğini artırır.

Kötü uygulamadan uzak olarak, Python (ve diğer diller?) forDöngü yapısını genişletti, böylelikle bir kısmı sadece döngü yapmazsa çalıştırılacak break .

for n in range(5):
    for m in range(3):
        if m >= n:
            print('stop!')
            break
        print(m, end=' ')
    else:
        print('finished.')

Çıktı:

stop!
0 stop!
0 1 stop!
0 1 2 finished.
0 1 2 finished.

Eşdeğer kod olmadan breakve bu kullanışlı else:

for n in range(5):
    aborted = False
    for m in range(3):
        if not aborted:
            if m >= n:
                print('stop!')
                aborted = True
            else:            
                print(m, end=' ')
    if not aborted:
        print('finished.')

Break ifadesini kullanmanın doğası gereği yanlış bir şey yoktur, ancak iç içe geçmiş döngüler kafa karıştırıcı olabilir. Okunabilirliği artırmak için birçok dil ( en azından Java destekler) okunabilirliği büyük ölçüde artıracak etiketlerin kırılmasını destekler.

int[] iArray = new int[]{0,1,2,3,4,5,6,7,8,9};
int[] jArray = new int[]{0,1,2,3,4,5,6,7,8,9};

// label for i loop
iLoop: for (int i = 0; i < iArray.length; i++) {

    // label for j loop
    jLoop: for (int j = 0; j < jArray.length; j++) {

        if(iArray[i] < jArray[j]){
            // break i and j loops
            break iLoop;
        } else if (iArray[i] > jArray[j]){  
            // breaks only j loop
            break jLoop;
        } else {
            // unclear which loop is ending
            // (breaks only the j loop)
            break;
        }
    }
}

Break (ve return) ifadelerinin çoğu zaman döngüsel karmaşıklığı artırdığını ve kodun her durumda doğru şeyi yaptığını kanıtlamayı zorlaştırdığını söyleyeceğim.

Belirli bir öğe için bir dizi üzerinde yinelerken bir ara kullanmayı düşünüyorsanız, verilerinizi tutmak için kullanılan veri yapısını yeniden gözden geçirmek isteyebilirsiniz. Set veya Harita gibi bir şey kullanmak daha iyi sonuçlar sağlayabilir.

ara kullanımı için tamamen kabul edilebilir bir ifadesidir (so devam btw). Her şey kod okunabilirliğiyle ilgili - aşırı karmaşık döngüleriniz olmadığı sürece sorun değil.

Goto ile aynı ligde değiller . :)

Genel kural: Bir kurala uymak, daha garip ve okunması zor bir şey yapmanızı, sonra kuralı çiğnemenizi gerektiriyorsa, o zaman kuralı çiğneyin.

Bir şey bulana kadar döngü halinde, çıktığınızda bulunan ve bulunmayanları ayırt etme problemiyle karşılaşırsınız. Yani:

for (int x=0;x<fooCount;++x)
{
  Foo foo=getFooSomehow(x);
  if (foo.bar==42)
    break;
}
// So when we get here, did we find one, or did we fall out the bottom?

Tamam, bir bayrak ayarlayabilir veya "bulunan" bir değeri sıfır olarak başlatabilirsiniz. Fakat

Bu yüzden genel olarak aramalarımı işlevlere itmeyi tercih ediyorum:

Foo findFoo(int wantBar)
{
  for (int x=0;x<fooCount;++x)
  {
    Foo foo=getFooSomehow(x);
    if (foo.bar==wantBar)
      return foo;
  }
  // Not found
  return null;
}

Bu aynı zamanda kodun dağınıklığına da yardımcı olur. Ana satırda, "bul" tek bir cümle haline gelir ve koşullar karmaşık olduğunda, yalnızca bir kez yazılır.

Dile bağlıdır. Burada bir boole değişkenini muhtemelen kontrol edebilirsiniz:

for (int i = 0; i < 100 && stayInLoop; i++) { ... }

bir dizi üzerinde yineleme yaparken bunu yapmak mümkün değildir:

for element in bigList: ...

Her neyse, breakher iki kodu da daha okunaklı hale getirir.

Örneğinizde, for döngüsü için yineleme sayısını bilmiyorsunuz . Bunun yerine neden yineleme sayısının başlangıçta belirsiz olmasına izin veren while döngüsü kullanılmasın?

Döngü bir while döngüsü olarak daha iyi ifade edilebileceğinden, genel olarak break ifadesini kullanmak gerekli değildir .

Kullanmayı öneren diğerlerine katılıyorum break. Sonuç olarak ortaya çıkan bariz soru, neden birinin aksini tavsiye etmesidir? Peki ... break kullandığınızda, bloktaki kodun geri kalanını ve kalan yinelemeleri atlarsınız. Bazen bu, hatalara neden olur, örneğin:

• bloğun tepesinde elde edilen bir kaynak altta serbest bırakılabilir (bu, fordöngülerin içindeki bloklar için bile geçerlidir ), ancak bu serbest bırakma adımı, bir breakifadeden ("modern" de) "erken" bir çıkışa neden olduğunda yanlışlıkla atlanabilir. C ++, "RAII", bunu güvenilir ve istisna korumalı bir şekilde ele almak için kullanılır: temel olarak, nesne yıkıcılar, kapsamdan nasıl çıkılırsa çıkılsın, kaynakları güvenilir bir şekilde serbest bırakır)

• başka biri for, başka yerinden ayrılmış çıkış koşulları olduğunu fark etmeden ifadedeki koşullu testi değiştirebilir

• ndim'in cevabı, bazı kişilerin breaknispeten tutarlı bir döngü çalışma süresi sağlamaktan kaçınabileceğini gözlemliyor , ancak breakbunun tutmadığı bir boole erken çıkış kontrol değişkeninin kullanımıyla karşılaştırıyorsunuz

Arada sırada bu tür hataları gözlemleyen insanlar, bu "kesinti yok" kuralı ile bunların önlenebileceğini / hafifletilebileceğini fark eder ... aslında, "yapılandırılmış programlama" adı verilen "daha güvenli" programlama için her bir işlevin sahip olması gereken bütün bir ilgili strateji vardır. tek bir giriş ve çıkış noktası da (yani gitme, erken dönüş yok). Bazı hataları ortadan kaldırabilir, ancak şüphesiz diğerlerini ortaya çıkarır. Neden yapıyorlar?

• belirli bir programlama / kod stilini teşvik eden bir geliştirme çerçevesine sahipler ve bunun bu sınırlı çerçevede net bir fayda sağladığına dair istatistiksel kanıtları var veya
• programlama yönergelerinden veya böyle bir çerçevedeki deneyimden etkilenmişlerse veya
• onlar sadece diktatörce aptallar veya
• yukarıdaki + tarihsel ataletlerin herhangi biri (gerekçelerin C için modern C ++ 'dan daha uygulanabilir olmasıyla ilgilidir).

Kullanması tamamen geçerli break- diğerlerinin de belirttiği gibi, aynı ligde hiçbir yerde değil goto.

Bununla birlikte vFound, değerin dizide bulunup bulunmadığını döngü dışında kontrol etmek istediğinizde değişkeni kullanmak isteyebilirsiniz. Aynı zamanda, sürdürülebilirlik açısından, çıkış kriterlerini işaret eden ortak bir bayrağa sahip olmak faydalı olabilir.

Şu anda üzerinde çalıştığım kod tabanı üzerinde bazı analizler yaptım (40.000 satır JavaScript).

breakBunlardan sadece 22 ifade buldum :

• switchİfadelerin içinde 19 kullanıldı (toplamda sadece 3 switch ifademiz var!).
• 2 fordöngülerin içinde kullanıldı - hemen ayrı işlevlere yeniden düzenlenecek ve returnifadeyle değiştirilecek şekilde sınıflandırdığım bir kod .
• Son breakiç whiledöngüye gelince ... git blameBu saçmalığı kimin yazdığını görmek için koştum !

Benim istatistiklere göre Yani: Eğer breakÖnceden kullanmış dışında switch, bir kod koku olduğunu.

Ayrıca continueifadeleri araştırdım . Hiçbiri bulunamadı.

O noktada DURDURMA işlemini tamamlamak istemenizin SAĞLANAN kötü bir uygulama olmasının nedenini göremiyorum.

Gömülü dünyada, aşağıdaki yapıyı kullanan birçok kod var:

    while(1)
    { 
         if (RCIF)
           gx();
         if (command_received == command_we_are_waiting_on)
           break;
         else if ((num_attempts > MAX_ATTEMPTS) || (TickGet() - BaseTick > MAX_TIMEOUT))
           return ERROR;
         num_attempts++;
    }
    if (call_some_bool_returning_function())
      return TRUE;
    else
      return FALSE;

Bu çok genel bir örnek, perde arkasında pek çok şey oluyor, özellikle kesiliyor. Bunu standart kod olarak kullanmayın, sadece bir örnek göstermeye çalışıyorum.

Benim kişisel görüşüm, döngüde süresiz olarak kalmayı önlemek için uygun özen gösterildiği sürece bu şekilde bir döngü yazmanın yanlış bir tarafı olmadığıdır.

Kullanım durumunuza bağlıdır. Bir for döngüsünün çalışma zamanının sabit olması gereken uygulamalar vardır (örneğin, bazı zamanlama kısıtlamalarını karşılamak veya veri dahili bilgilerinizi zamanlama tabanlı saldırılardan gizlemek için).

Bu durumlarda, bir bayrak ayarlamak ve yalnızca tüm fordöngü yinelemeleri gerçekten çalıştıktan SONRA bayrak değerini kontrol etmek bile mantıklı olacaktır . Elbette, tüm for döngüsü yinelemelerinin hala aynı süreyi alan kodu çalıştırması gerekir.

Çalışma süresi sizin için önemli değilse ... kodun okunmasını kolaylaştırmak için break;ve continue;kullanın.

On MISRA C dev Şirketim kullanılan 98 kural, break ifadesi kullanılmayacaktır ...

Düzenleme: MISRA '04'te kesintiye izin verilir

Elbette, break;for döngüsünü veya foreach döngüsünü durdurmanın çözümü. Bunu php'de foreach ve for döngüsünde kullandım ve çalışıyor buldum.

Katılmıyorum!

Kendinizinkini oluşturmak için bir for döngüsünün yerleşik işlevini neden göz ardı edesiniz? Tekerleği yeniden icat etmenize gerek yok.

Bence çeklerinizin for döngüsünün en üstünde olması daha mantıklı.

for(int i = 0; i < myCollection.Length && myCollection[i].SomeValue != "Break Condition"; i++)
{
//loop body
}

veya önce satırı işlemeniz gerekiyorsa

for(int i = 0; i < myCollection.Length && (i == 0 ? true : myCollection[i-1].SomeValue != "Break Condition"); i++)
{
//loop body
}

Bu şekilde, her şeyi gerçekleştirmek ve çok daha temiz kod yapmak için bir işlev yazabilirsiniz.

for(int i = 0; i < myCollection.Length && (i == 0 ? true : myCollection[i-1].SomeValue != "Break Condition"); i++)
{
    DoAllThatCrazyStuff(myCollection[i]);
}

Veya durumunuz karmaşıksa, bu kodu da taşıyabilirsiniz!

for(int i = 0; i < myCollection.Length && BreakFunctionCheck(i, myCollection); i++)
{
    DoAllThatCrazyStuff(myCollection[i]);
}

Molalarla dolu "Profesyonel Kod" bana pek profesyonel kod gibi gelmiyor. Tembel kodlamaya benziyor;)