“While (true)” döngüleri çok mu kötü? [kapalı]

Birkaç yıldır Java'da program yapıyorum, ancak yakın zamanda resmi bir derece almak için okula döndüm. Son görevimde aşağıdaki gibi bir döngü kullandığım için puan kaybettiğimi öğrenmek beni oldukça şaşırttı.

do{
     //get some input.
     //if the input meets my conditions, break;
     //Otherwise ask again.
} while(true)

Şimdi testim için sadece bazı konsol girişleri için tarama yapıyorum, ancak bu tür bir döngünün cesaretinin kırıldığı söylendi, çünkü breakkullanım benzer goto, sadece yapmıyoruz.

gotoJava kuzeninin tuzaklarını ve tam anlamıyla anlıyorum ve break:labelonları kullanmamanın iyi bir anlamı var. Ayrıca, daha eksiksiz bir programın, örneğin programı sonlandırmak için başka bir kaçış yolu sağlayacağını da fark ettim, ancak bu, profesörümün belirttiği bir sebep değildi, bu yüzden ...

Sorun nedir do-while(true)?

Söylemem Kötü - ama aynı şekilde normalde en azından bir alternatif ararım.

Yazdığım ilk şeyin olduğu durumlarda, neredeyse her zaman en azından onu daha net bir şeye dönüştürmeye çalışırım . Bazen yardım edilemez (ya da alternatif birbool döngünün sonunu belirtmek dışında anlamlı olmayan hiçbir şey yapmayan değişkene sahip bir breakifadeden daha az açıktır ) ama en azından denemeye değer.

breakBir bayraktan daha açık nerede kullanıldığına bir örnek olarak şunları göz önünde bulundurun:

while (true)
{
    doStuffNeededAtStartOfLoop();
    int input = getSomeInput();
    if (testCondition(input))
    {
        break;
    }
    actOnInput(input);
}

Şimdi bir bayrak kullanmaya zorlayalım:

boolean running = true;
while (running)
{
    doStuffNeededAtStartOfLoop();
    int input = getSomeInput();
    if (testCondition(input))
    {
        running = false;
    }
    else
    {
        actOnInput(input);
    }
}

İkincisini okumak için daha karmaşık olarak görüyorum: ekstra bir elsebloğu var actOnInput, daha girintili ve eğer testConditiongeri döndüğünde ne olacağını bulmaya çalışıyorsanız true, orada kontrol etmek için bloğun geri kalanına dikkatlice bakmanız gerekir. bir şey değil sonraelse mı oluşacak bloğuna runningolarak ayarlandı falseya da değil.

breakİfadesi daha net niyet iletişim kurar ve bloğun geri kalanı daha önce koşulları hakkında endişelenmeden yapması gereken yapmalarına olanak tanır.

Bunun, insanların bir yöntemde birden çok döndürme ifadesine sahip olduğu gibi aynı argüman olduğunu unutmayın. Örneğin, ilk birkaç satırdaki bir yöntemin sonucunu çözebilirsem (örneğin, bazı girdiler boş, boş veya sıfır olduğu için), bu yanıtı doğrudan sonucu depolamak için bir değişkene sahip olmaktan daha açık bir şekilde döndürürüm , daha sonra başka bir kod bloğu ve son olarak bir returnifade.

AFAIK hiçbir şey, gerçekten. Öğretmenler alerjisi var goto, çünkü bir yerde gerçekten kötü olduğunu duydular. Aksi takdirde şunu yazarsınız:

bool guard = true;
do
{
   getInput();
   if (something)
     guard = false;
} while (guard)

Bu neredeyse aynı şey.

Belki bu daha temizdir (çünkü tüm döngü bilgileri bloğun üstünde bulunur):

for (bool endLoop = false; !endLoop;)
{

}

Douglas Crockford, JavaScript'in nasıl bir loopyapı içermesini istediğine dair bir açıklama yaptı :

loop
{
  ...code...
}

Ve sanmıyorum Java a sahip herhangi kötü olurduloop yapıya .

İle doğal olarak yanlış bir şey yok while(true)döngüler, ama orada olduğunu , onları vazgeçirmek için öğretmenler için bir eğilim. Öğretme perspektifinden bakıldığında, öğrencilerin sonsuz döngüler oluşturmaları ve döngünün neden hiç kaçmadığını anlamaması çok kolaydır.

Ancak nadiren bahsettikleri, tüm döngü mekanizmalarının while(true)döngülerle çoğaltılabileceğidir .

while( a() )
{
  fn();
}

aynıdır

loop
{
  if ( !a() ) break;
  fn();
}

ve

do
{
  fn();
} while( a() );

aynıdır:

loop
{
  fn();
  if ( !a() ) break;
}

ve

for ( a(); b(); c() )
{
  fn();
}

aynıdır:

a();
loop
{
  if ( !b() ) break;
  fn();
  c();
}

Döngülerinizi kullanmayı seçtiğiniz yapıda çalışacak şekilde ayarlayabildiğiniz sürece önemsizdir. O Eğer olur bir sığacak şekilde fordöngü, bir kullanmak fordöngü.

Son bir bölüm: döngülerinizi basit tutun. Her yinelemede olması gereken çok fazla işlevsellik varsa, onu bir işleve yerleştirin. Çalıştırdıktan sonra her zaman optimize edebilirsiniz.

1967'de Edgar Dijkstra, bir ticaret dergisinde kod kalitesini artırmak için neden üst düzey dillerden kaldırılması gerektiğine dair bir makale yazdı. "Yapısal programlama" adı verilen bir programlama paradigması ortaya çıktı, ancak kesinlikle herkes otomatik olarak kötü kod anlamına geldiğini kabul etmiyor.

Yapısal programlamanın özü, esasen kodun yapısının, gitmesi veya kırılması yerine akışını belirlemesi veya mümkün olan yerlerde akışı belirlemeye devam etmesidir. Aynı şekilde, bir döngü veya işleve birden çok giriş ve çıkış noktası olması da bu paradigmada önerilmez.

Açıkçası bu tek programlama paradigması değildir, ancak genellikle nesne yönelimli programlama (ala Java) gibi diğer paradigmalara da kolayca uygulanabilir.

Öğretmenleriniz muhtemelen öğretilmiştir ve sınıfınıza, kodumuzun yapılandırıldığından emin olarak ve yapılandırılmış programlama kurallarını izleyerek "spagetti kodundan" en iyi kaçınacağımızı öğretmeye çalışmaktadır.

Break kullanan bir uygulamada doğal olarak "yanlış" bir şey olmasa da, bazıları, while () koşulu içinde loop koşulunun açıkça belirtildiği ve aşırı derecede zor olma olasılıklarını ortadan kaldırdığı kodun okunmasını önemli ölçüde kolaylaştırır. Yanlışlıkla sonsuz bir döngü oluşturma veya okunması zor veya gereksiz bir şekilde kafa karıştırıcı kod yapma riski gibi acemi programcılar tarafından kodda sıkça ortaya çıkan bir süre (gerçek) koşulu kullanmanın kesinlikle tuzakları vardır.

İronik olarak, istisna işleme, yapılandırılmış programlamadan sapmanın kesinlikle ortaya çıkacağı ve Java'da programlamaya daha fazla girdiğinizde beklenen bir alandır.

Eğitmeniniz, metninizin o bölümünde veya dersinde öğretilen belirli bir döngü yapısını veya sözdizimini kullanma yeteneğinizi göstermenizi beklemiş olabilir ve yazdığınız kod işlevsel olarak eşdeğer olsa da, o derste öğrenmeniz gerekiyordu.

Girişi okumak için olağan Java kuralı:

import java.io.*;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String strLine;

while ((strLine = br.readLine()) != null) {
  // do something with the line
}

Ve girişi okumak için her zamanki C ++ kuralı:

#include <iostream>
#include <string>
std::string data;
while(std::readline(std::cin, data)) {
  // do something with the line
}

Ve C de,

#include <stdio.h>
char* buffer = NULL;
size_t buffer_size;
size_t size_read;
while( (size_read = getline(&buffer, &buffer_size, stdin)) != -1 ){
  // do something with the line
}
free(buffer);

veya dosyanızdaki en uzun metin satırının ne kadar uzun olduğunu bildiğinize ikna olduysanız,

#include <stdio.h>
char buffer[BUF_SIZE];
while (fgets(buffer, BUF_SIZE, stdin)) {
  //do something with the line
}

Kullanıcının bir quitkomut girip girmediğini test ediyorsanız , bu 3 döngü yapısından herhangi birini genişletmek kolaydır. Bunu sizin için Java'da yapacağım:

import java.io.*;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line;

while ((line = br.readLine()) != null  && !line.equals("quit") ) {
  // do something with the line
}

Bu nedenle, kesinlikle breakveya gotohaklı olduğu durumlar olsa da , yaptığınız tek şey bir dosyadan veya konsoldan satır satır while (true)okumaksa, bunu gerçekleştirmek için bir döngüye ihtiyacınız olmamalıdır - programlama diliniz zaten size loop koşul olarak input komutunu kullanmak için uygun bir deyim ile.

Bu korkunç bir şey değil, ancak kodlarken diğer geliştiricileri de dikkate almanız gerekiyor. Okulda bile.

Geliştiricileriniz, döngü bildiriminde döngü için çıkış yan tümcesini görebilmelidir. Bunu sen yapmadın. Çıkış yan tümcesini döngünün ortasına sakladınız ve birlikte gelen ve kodunuzu anlamaya çalışan biri için daha fazla iş yaptınız. Bu "mola" gibi şeylerden kaçınılmasıyla aynı nedendir.

Bununla birlikte, gerçek dünyada hala bir sürü kodda böyle şeyler göreceksiniz.

Bu senin silahın, mermin ve ayağın ...

Kötü çünkü sorun istiyorsun. Siz veya bu sayfadaki kısa / basit hal döngüleri örnekleri olan diğer posterlerden herhangi biri olmayacak.

Sorun gelecekte çok rastgele bir zamanda başlayacak. Başka bir programcıdan kaynaklanıyor olabilir. Yazılımı yükleyen kişi olabilir. Son kullanıcı olabilir.

Neden? Bir 700K LOC uygulamasının neden her CPU dolana kadar CPU zamanının% 100'ünü yavaş yavaş yakmaya başlayacağını bulmak zorundaydım. Bu inanılmaz bir (gerçek) döngü oldu. Büyük ve iğrençti ama aşağıya kaynatıldı:

x = read_value_from_database()
while (true) 
 if (x == 1)
  ...
  break;
 else if (x ==2)
  ...
  break;
and lots more else if conditions
}

Başka bir son şube yoktu. Değer bir if koşuluyla eşleşmezse, döngü zaman sonuna kadar çalışmaya devam etti.

Tabii ki, programcı son kullanıcıları programcının beklediği bir değer seçmedikleri için suçladı. (Daha sonra koddaki while (true) tüm örneklerini kaldırdım.)

IMHO while (true) gibi yapıları kullanmak iyi bir savunma programı değildir. Size musallat olmak için geri gelecek.

(Ama i ++ için bile her satıra yorum yapmadıysak not verdim profesörleri hatırlıyorum;)

Yapısal programlama yapılarının (biraz yapılandırılmamış) kesme ve devam etme ifadelerine tercih edilmesi anlamında kötüdür. Karşılaştırma yapılarak, bu prensibe göre "goto" ya tercih edilirler.

Kodunuzu her zaman mümkün olduğunca yapılandırılmış hale getirmenizi öneririm ... Jon Skeet'in de belirttiği gibi, kodunuzu bundan daha yapılandırılmış yapmayın!

Deneyimlerime göre çoğu durumda döngüler devam etmek için "ana" koşula sahiptir. Bu while () operatörünün kendisine yazılması gereken durumdur. Döngüyü kırabilecek tüm diğer koşullar ikincil, çok önemli değil vb. Bunlar ek if() {break}ifadeler olarak yazılabilir .

while(true) genellikle kafa karıştırıcıdır ve daha az okunabilir.

Bu kuralların vakaların% 100'ünü değil, muhtemelen sadece% 98'ini kapsadığını düşünüyorum.

Neden kullanılmamaya ilişkin bir cevap olmasa da while (true), her zaman bu komik ve eşlik eden yazarın ifadesini buldum yapmak yerine neden yapılması gerektiğine dair kısa ve öz bir açıklama .

Sorunuzla ilgili olarak: ile ilgili doğal bir sorun yoktur.

while(true) {
   do_stuff();
   if(exit_time) {
      break;
   }
}

... ne yaptığınızı biliyorsanız ve bir exit_timenoktada bununtrue .

Öğretmenler sizi kullanmaktan caydırır, while(true)çünkü ne yaptığınızı tam olarak bildiğiniz noktaya gelene kadar kritik bir hata yapmanın kolay bir yoludur.

While döngüsünün ne zaman sonlandırılacağını belirtmek için bir Boole bayrağı kullanabilirsiniz. Breakvego to yazılımın bakımı zor olmak için nedenlerdi - yazılım krizi (tm) - ve bundan kaçınılmalıdır ve kolayca da olabilir.

Eğer pragmatik ya da değil bir soru. Pragmatik kodlayıcılar bu basit durumda mola kullanabilirler.

Ancak bunları kullanmama alışkanlığını elde etmek iyidir, aksi takdirde bunları, kodunuzun okunabilirliğinin ve sürdürülebilirliğinin zorlaştığı karmaşık iç içe döngülerde olduğu gibi, uygun olmayan durumlarda alışkanlık dışında kullanabilirsiniz break.

Belki şanssızım. Ya da belki de bir deneyimim yok. Ama başa hatırlıyorum her zaman while(true)sahip breakiçeride, uygulamadan kodu geliştirmek mümkün oldu Özü Yöntemi için ise blok tuttu, while(true)bütün dönüştürülmüş ancak (tesadüfen?) breakİçine ler returns.

Deneyimlerime göre ara while(true)vermeden (yani geri dönüşler veya atışlarla) oldukça rahat ve anlaşılması kolaydır.

  void handleInput() {
      while (true) {
          final Input input = getSomeInput();
          if (input == null) {
              throw new BadInputException("can't handle null input");
          }
          if (input.isPoisonPill()) {
              return;
          }
          doSomething(input);
      }
  }

Bence evet oldukça kötü ... ya da en azından birçok geliştirici için. Döngü koşullarını düşünmeyen geliştiricilerin semptomatiktir. Sonuç olarak hata eğilimli olur.

İle hiçbir önemli sorun var while(true)olanbreak tablolar, ancak bazı onun biraz kod okunabilirliği azaltır düşünebilir. Değişkenlere anlamlı adlar vermeye çalışın, ifadeleri uygun yerde değerlendirin.

Örneğin, şöyle bir şey yapmak çok daha net görünüyor:

do {
   input = get_input();
   valid = check_input_validity(input);    
} while(! valid)

Bu, while döngüsü uzun sürerse özellikle doğrudur - ek bir yinelemenin olup olmadığını görmek için denetimin tam olarak nerede olduğunu bilirsiniz. Tüm değişkenler / işlevler soyutlama düzeyinde uygun isimlere sahiptir. while(true)Açıklamada, işleme, düşünce yerinde olmadığı söylemek etmez.

Belki döngüden ikinci kez farklı çıktılar istersiniz. Gibi bir şey

input = get_input();
while(input_is_not_valid(input)) {
    disp_msg_invalid_input();
    input = get_input();
}

o zaman bana daha okunabilir görünüyor

do {
    input = get_input();
    if (input_is_valid(input)) {
        break;
    }
    disp_msg_invalid_input();
} while(true);

Yine, önemsiz bir örnekle her ikisi de oldukça okunabilir; ancak döngü çok büyük veya derin yuvalanmışsa (muhtemelen zaten yeniden düzenlenmiş olmanız gerektiği anlamına gelir), ilk stil biraz daha net olabilir.

Birçok fonksiyonumda benzer bir şey kullanıyorum, fakat karşıt mantıkla.

DWORD dwError = ERROR_SUCCESS;

do
{
    if ( (dwError = SomeFunction()) != ERROR_SUCCESS )
    {
         /* handle error */
         continue;
    }

    if ( (dwError = SomeOtherFunction()) != ERROR_SUCCESS )
    {
         /* handle error */
         continue;
    }
}
while ( 0 );

if ( dwError != ERROR_SUCCESS )
{
    /* resource cleanup */
}

Bu daha çok estetik bir şeydir, döngüyü neden döngü bildiriminde durduracağını açıkça bildiğiniz kodu okumak çok daha kolaydır .

Genel olarak iyi bir fikir olarak görülmemesinin nedeninin, yapıyı tam potansiyeline kullanmamanız olduğunu söyleyebilirim. Ayrıca, birçok programlama eğitmeninin öğrencileri "bagaj" ile geldiklerinde bundan hoşlanmadığını düşünüyorum. Demek istediğim, öğrencilerin programlama tarzı üzerinde birincil etki olmayı severler. Belki de bu sadece eğitmenlerin evcil hayvanı.

Bana göre sorun okunabilirlik.

Gerçek koşullu bir while ifadesi döngü hakkında hiçbir şey söylemez. Anlama işini çok daha zorlaştırır.

Bu iki parçacıktan anlaşılması daha kolay ne olabilir?

do {
  // Imagine a nice chunk of code here
} while(true);

do {
  // Imagine a nice chunk of code here
} while(price < priceAllowedForDiscount);

Sanırım öğretmeninize mola vermek, meyveyi almak için bir ağaç dalını kırmak, diğer hileleri kullanmak (dalı yay) gibi olur, böylece meyveyi alırsınız ve dal hala canlıdır. :)

1) Hiçbir şey yanlış do -while(true)

2) Öğretmeniniz yanlış.

NSFs !!:

3) Çoğu öğretmen programcı değil öğretmendir.

Döngünüzün bir arka plan iş parçacığı üzerinde çalışması kötü olabilir, bu nedenle bir UI iş parçacığını sonlandırarak uygulamanızı kapattığınızda, bu kod parçası yürütülmeye devam eder. Diğerlerinin söylediği gibi, iptal için bir yol sağlamak için her zaman bir tür kontrol kullanmalısınız.