Apakah loop (sementara) benar-benar buruk? [Tutup]

Saya sudah pemrograman di Jawa selama beberapa tahun sekarang, tetapi saya baru saja kembali ke sekolah untuk mendapatkan gelar formal. Saya cukup terkejut mengetahui bahwa, pada tugas terakhir saya, saya kehilangan poin karena menggunakan loop seperti di bawah ini.

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

Sekarang untuk pengujian saya, saya hanya memindai beberapa input konsol, tetapi saya diberitahu bahwa loop semacam ini tidak dianjurkan karena menggunakan breakmirip dengan goto, kami hanya tidak melakukannya.

Saya mengerti sepenuhnya perangkap gotodan sepupu Java-nya break:label, dan saya memiliki akal sehat untuk tidak menggunakannya. Saya juga menyadari bahwa program yang lebih lengkap akan memberikan cara lain untuk melarikan diri, misalnya untuk mengakhiri saja program tersebut, tetapi itu bukan alasan yang dikutip oleh profesor saya, jadi ...

Ada apa dengan ini do-while(true)?

Saya tidak akan mengatakan itu buruk - tetapi sama-sama biasanya saya setidaknya akan mencari alternatif.

Dalam situasi di mana ini adalah hal pertama yang saya tulis, saya hampir selalu setidaknya mencoba untuk mengubahnya menjadi sesuatu yang lebih jelas. Kadang-kadang itu tidak dapat membantu (atau alternatifnya adalah memiliki boolvariabel yang tidak melakukan apa pun yang berarti kecuali menunjukkan akhir dari loop, kurang jelas dari sebuah breakpernyataan) tetapi ada baiknya setidaknya mencoba.

Sebagai contoh penggunaan yang lebih jelas breakdaripada bendera, pertimbangkan:

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

Sekarang mari kita paksa untuk menggunakan bendera:

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

Saya melihat yang terakhir sebagai lebih rumit untuk dibaca: ada elseblok tambahan , actOnInputlebih indentasi, dan jika Anda mencoba mencari tahu apa yang terjadi ketika testConditionkembali true, Anda perlu melihat dengan hati-hati melalui sisa blok untuk memeriksa bahwa ada bukan sesuatu setelah itu elseblok yang akan terjadi apakah runningtelah ditetapkan ke falseatau tidak.

The breakpernyataan berkomunikasi maksud lebih jelas, dan memungkinkan sisa blok melanjutkan apa yang perlu dilakukan tanpa khawatir tentang kondisi sebelumnya.

Perhatikan bahwa argumen ini persis sama dengan argumen yang dimiliki orang tentang beberapa pernyataan pengembalian dalam suatu metode. Sebagai contoh, jika saya dapat menentukan hasil metode dalam beberapa baris pertama (misalnya karena beberapa input adalah nol, atau kosong, atau nol) saya merasa lebih jelas untuk mengembalikan jawaban itu secara langsung daripada memiliki variabel untuk menyimpan hasilnya , lalu seluruh blok kode lain, dan akhirnya sebuah returnpernyataan.

AFAIK tidak ada, sungguh. Guru hanya alergi goto, karena mereka mendengar di suatu tempat itu sangat buruk. Kalau tidak, Anda hanya akan menulis:

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

Yang merupakan hal yang hampir sama.

Mungkin ini lebih bersih (karena semua info perulangan terdapat di bagian atas blok):

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

}

Douglas Crockford memiliki komentar tentang bagaimana ia berharap JavaScript mengandung loopstruktur:

loop
{
  ...code...
}

Dan saya tidak berpikir Java akan lebih buruk karena memiliki loopstruktur juga.

Tidak ada yang salah dengan while(true)loop, tapi ada adalah kecenderungan bagi guru untuk mencegah mereka. Dari perspektif pengajaran, sangat mudah untuk membuat siswa membuat loop tanpa akhir dan tidak mengerti mengapa loop tidak pernah lolos.

Tetapi apa yang jarang mereka sebutkan adalah bahwa semua mekanisme perulangan dapat direplikasi dengan while(true)loop.

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

sama dengan

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

dan

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

sama dengan:

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

dan

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

sama dengan:

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

Selama Anda dapat mengatur loop Anda dengan cara yang bekerja membangun yang Anda pilih untuk digunakan tidak penting. Jika kebetulan pas dalam satu forlingkaran, gunakan satu forlingkaran.

Satu bagian terakhir: jaga agar loop Anda tetap sederhana. Jika ada banyak fungsi yang perlu terjadi pada setiap iterasi, letakkan di fungsi. Anda selalu dapat mengoptimalkannya setelah berhasil.

Kembali pada tahun 1967, Edgar Dijkstra menulis sebuah artikel di majalah perdagangan tentang mengapa goto harus dihilangkan dari bahasa tingkat tinggi untuk meningkatkan kualitas kode. Paradigma pemrograman keseluruhan yang disebut "pemrograman terstruktur" keluar dari ini, meskipun tentu tidak semua orang setuju bahwa goto secara otomatis berarti kode yang buruk.

Inti dari pemrograman terstruktur pada dasarnya adalah bahwa struktur kode harus menentukan alirannya daripada memiliki gotos atau istirahat atau terus menentukan aliran, sedapat mungkin. Demikian pula, memiliki beberapa titik masuk dan keluar ke loop atau fungsi juga tidak disarankan dalam paradigma itu.

Jelas ini bukan satu-satunya paradigma pemrograman, tetapi seringkali dapat dengan mudah diterapkan pada paradigma lain seperti pemrograman berorientasi objek (ala Java).

Guru-guru Anda mungkin telah diajar, dan sedang berusaha mengajar kelas Anda bahwa kami sebaiknya menghindari "kode spageti" dengan memastikan kode kami terstruktur, dan mengikuti aturan tersirat pemrograman terstruktur.

Sementara tidak ada yang secara inheren "salah" dengan implementasi yang menggunakan break, beberapa menganggapnya lebih mudah untuk membaca kode di mana kondisi untuk loop secara eksplisit ditentukan dalam kondisi while (), dan menghilangkan beberapa kemungkinan menjadi terlalu rumit. Pasti ada jebakan untuk menggunakan kondisi sementara (benar) yang tampaknya sering muncul dalam kode oleh programmer pemula, seperti risiko tidak sengaja membuat loop tak terbatas, atau membuat kode yang sulit dibaca atau membingungkan.

Ironisnya, penanganan pengecualian adalah area di mana penyimpangan dari pemrograman terstruktur pasti akan muncul dan diharapkan saat Anda masuk lebih jauh ke pemrograman di Jawa.

Mungkin juga instruktur Anda mungkin mengharapkan Anda untuk mendemonstrasikan kemampuan Anda untuk menggunakan struktur lingkaran atau sintaksis tertentu yang diajarkan dalam bab atau pelajaran teks Anda, dan sementara kode yang Anda tulis setara secara fungsional, Anda mungkin tidak menunjukkan keterampilan khusus yang seharusnya Anda pelajari dalam pelajaran itu.

Konvensi Java ususal untuk input bacaan adalah:

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

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

Dan konvensi C ++ biasa untuk membaca input adalah:

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

Dan di C, itu

#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);

atau jika Anda yakin tahu berapa lama baris teks terpanjang dalam file Anda, Anda bisa melakukannya

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

Jika Anda menguji untuk melihat apakah pengguna Anda memasukkan quitperintah, mudah untuk memperpanjang salah satu dari 3 struktur loop ini. Saya akan melakukannya di Jawa untuk Anda:

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
}

Jadi, walaupun pasti ada kasus-kasus di mana breakatau gotodibenarkan, jika semua yang Anda lakukan adalah membaca dari file atau konsol baris demi baris, maka Anda seharusnya tidak perlu while (true)loop untuk mencapainya - bahasa pemrograman Anda telah menyediakan Anda dengan idiom yang sesuai untuk menggunakan perintah input sebagai kondisi loop.

Ini bukan hal yang mengerikan, tetapi Anda harus mempertimbangkan pengembang lain saat melakukan pengkodean. Bahkan di sekolah.

Rekan pengembang Anda harus dapat melihat klausa keluar untuk loop Anda, pada deklarasi loop. Kamu tidak melakukan itu. Anda menyembunyikan klausa keluar di tengah-tengah loop, membuat lebih banyak pekerjaan untuk orang lain yang datang dan mencoba memahami kode Anda. Ini adalah alasan yang sama sehingga hal-hal seperti "istirahat" dihindari.

Yang sedang berkata, Anda masih akan melihat hal-hal seperti ini dalam BANYAK kode di dunia nyata.

Ini pistol Anda, peluru dan kaki Anda ...

Itu buruk karena Anda meminta masalah. Bukan Anda atau poster lain di halaman ini yang memiliki contoh loop pendek / sederhana.

Masalahnya akan mulai pada waktu yang sangat acak di masa depan. Mungkin disebabkan oleh programmer lain. Mungkin orang yang menginstal perangkat lunak. Mungkin pengguna akhir.

Mengapa? Saya harus mencari tahu mengapa aplikasi 700K LOC secara bertahap akan mulai membakar 100% dari waktu CPU sampai setiap CPU jenuh. Itu adalah loop while (true) yang menakjubkan. Itu besar dan menjijikkan, tetapi akhirnya menjadi:

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

Tidak ada cabang final lain. Jika nilai tidak cocok dengan kondisi if, loop terus berjalan hingga akhir waktu.

Tentu saja, programmer menyalahkan pengguna akhir karena tidak memilih nilai yang diharapkan oleh programmer. (Saya kemudian menghapus semua instance while (true) dalam kode.)

IMHO itu bukan pemrograman defensif yang baik untuk menggunakan konstruksi seperti while (true). Itu akan kembali menghantui Anda.

(Tapi saya ingat profesor menilai jika kita tidak berkomentar setiap baris, bahkan untuk i ++;)

Ini buruk dalam arti bahwa konstruksi pemrograman terstruktur lebih disukai daripada (yang agak tidak terstruktur) istirahat dan melanjutkan pernyataan. Sebagai perbandingan, mereka lebih disukai daripada "kebagian" menurut prinsip ini.

Saya selalu merekomendasikan untuk membuat kode Anda terstruktur mungkin ... meskipun, seperti yang ditunjukkan Jon Skeet, jangan membuatnya lebih terstruktur daripada itu!

Menurut pengalaman saya dalam banyak kasus, loop memiliki kondisi "utama" untuk melanjutkan. Ini adalah kondisi yang harus ditulis ke dalam () operator itu sendiri. Semua kondisi lain yang dapat memutus loop adalah sekunder, tidak begitu penting dll. Mereka dapat ditulis sebagai if() {break}pernyataan tambahan .

while(true) sering membingungkan dan kurang bisa dibaca.

Saya pikir aturan-aturan ini tidak mencakup 100% kasus tetapi mungkin hanya 98%.

Meskipun tidak selalu merupakan jawaban mengapa tidak menggunakan while (true), saya selalu menemukan komik ini dan menyertai pernyataan penulis penjelasan singkat tentang mengapa melakukan sementara bukan melakukan-saat.

Sehubungan dengan pertanyaan Anda: Tidak ada masalah yang melekat dengannya

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

... jika Anda tahu apa yang Anda lakukan dan memastikan bahwa exit_timepada titik tertentu akan dievaluasi true.

Guru mencegah Anda menggunakan while(true)karena sampai dan kecuali Anda pada titik yang Anda tahu persis apa yang Anda lakukan, itu adalah cara mudah untuk membuat kesalahan kritis.

Anda mungkin hanya menggunakan bendera Boolean untuk menunjukkan kapan harus mengakhiri loop while. Breakdan go toalasan mengapa perangkat lunak sulit dipertahankan - krisis perangkat lunak (tm) - dan harus dihindari, dan bisa juga mudah.

Ini pertanyaan apakah Anda pragmatis atau tidak. Coders pragmatis mungkin hanya menggunakan break dalam situasi sederhana itu.

Tapi itu baik untuk mendapatkan kebiasaan untuk tidak menggunakannya, jika tidak, Anda dapat menggunakannya dari kebiasaan dalam situasi yang tidak cocok, seperti dalam loop bersarang rumit di mana keterbacaan dan pemeliharaan kode Anda menjadi lebih sulit dengan menggunakan break.

Mungkin saya kurang beruntung. Atau mungkin saya hanya kurang pengalaman. Tetapi setiap kali saya ingat berurusan dengan while(true)memiliki breakdi dalam, adalah mungkin untuk meningkatkan kode menerapkan Metode Ekstrak ke -blok sementara , yang membuat while(true)tetapi (secara kebetulan?) Mengubah semua breaks menjadi returns.

Dalam pengalaman saya while(true)tanpa istirahat (yaitu dengan pengembalian atau lemparan) cukup nyaman dan mudah dimengerti.

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

Saya pikir ya itu sangat buruk ... atau setidaknya, bagi banyak pengembang. Ini adalah gejala dari pengembang yang tidak memikirkan kondisi loop mereka. Akibatnya ada kesalahan rawan.

Tidak ada masalah besar while(true)dengan breakpernyataan, namun beberapa orang mungkin berpikir itu sedikit menurunkan keterbacaan kode. Cobalah untuk memberikan variabel nama yang bermakna, mengevaluasi ekspresi di tempat yang tepat.

Sebagai contoh Anda, tampaknya lebih jelas untuk melakukan sesuatu seperti:

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

Ini terutama benar jika loop do while menjadi panjang - Anda tahu persis di mana centang untuk melihat apakah ada iterasi tambahan yang terjadi. Semua variabel / fungsi memiliki nama yang sesuai di tingkat abstraksi. The while(true)pernyataan tidak adalah memberitahu Anda pengolahan yang tidak di tempat yang Anda pikir.

Mungkin Anda ingin output yang berbeda pada kali kedua melalui loop. Sesuatu seperti

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

sepertinya lebih mudah dibaca oleh saya

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

Sekali lagi, dengan contoh sepele keduanya cukup mudah dibaca; tetapi jika loop menjadi sangat besar atau sangat bersarang (yang berarti Anda mungkin seharusnya sudah refactored), gaya pertama mungkin sedikit lebih jelas.

Saya menggunakan sesuatu yang serupa, tetapi dengan logika yang berlawanan, dalam banyak fungsi saya.

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 */
}

Ini lebih merupakan hal estetika, lebih mudah untuk membaca kode di mana Anda secara eksplisit tahu mengapa loop akan berhenti tepat di deklarasi loop.

Saya akan mengatakan bahwa secara umum alasan itu tidak dianggap ide yang baik adalah bahwa Anda tidak menggunakan konstruk untuk potensi penuh itu. Juga, saya cenderung berpikir bahwa banyak instruktur pemrograman tidak suka ketika siswa mereka datang dengan "bagasi". Maksud saya, saya pikir mereka suka menjadi pengaruh utama pada gaya pemrograman siswa mereka. Jadi mungkin itu hanya kesal dari instruktur.

Bagi saya, masalahnya adalah keterbacaan.

Pernyataan sementara dengan kondisi sebenarnya tidak memberi tahu Anda tentang loop. Itu membuat pekerjaan memahaminya jauh lebih sulit.

Apa yang akan lebih mudah dipahami dari kedua cuplikan ini?

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

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

Saya kira menggunakan istirahat untuk guru Anda seperti mematahkan sebatang pohon untuk mendapatkan buah, menggunakan beberapa trik lain (membungkuk cabang) sehingga Anda mendapatkan buah dan cabang masih hidup. :)

1) Tidak ada yang salah dengan a do -while(true)

2) Guru Anda salah.

NSFS !!:

3) Kebanyakan guru adalah guru dan bukan programmer.

Mungkin buruk jika loop Anda berjalan di utas latar belakang, jadi ketika Anda menutup aplikasi Anda dengan mengakhiri utas UI, potongan kode itu akan terus dijalankan. Seperti yang sudah dikatakan orang lain, Anda harus selalu menggunakan semacam cek untuk memberikan cara pembatalan.