Apakah ini membenarkan pernyataan goto?

Saya menemukan pertanyaan ini beberapa detik yang lalu, dan saya menarik beberapa materi dari sana: Apakah ada nama untuk konstruksi 'break n'?

Ini tampaknya menjadi cara rumit yang tidak perlu bagi orang-orang untuk menginstruksikan program untuk keluar dari double-nested for loop:

for (i = 0; i < 10; i++) {
    bool broken = false;
    for (j = 10; j > 0; j--) {
        if (j == i) {
            broken = true;
            break;
        }
    }
    if (broken)
        break;
}

Saya tahu buku-buku teks suka mengatakan pernyataan goto adalah iblis, dan saya sendiri tidak suka sama sekali, tetapi apakah ini membenarkan pengecualian terhadap aturan tersebut?

Saya mencari jawaban yang berhubungan dengan n-nested for loop.

CATATAN: Apakah Anda menjawab ya, tidak, atau di suatu tempat di antara, jawaban yang benar-benar tertutup tidak diterima. Terutama jika jawabannya tidak, maka berikan alasan yang baik dan sah mengapa (yang tidak terlalu jauh dari peraturan Stack Exchange).

Kebutuhan nyata untuk pernyataan masuk muncul dari Anda memilih ekspresi kondisional yang buruk untuk loop .

Anda menyatakan bahwa Anda ingin lingkaran luar terus berlanjut selama i < 10dan yang terdalam terus berlanjut selama j > 0.

Tetapi pada kenyataannya bukan itu yang Anda inginkan , Anda tidak memberi tahu loop kondisi sebenarnya yang Anda ingin mereka evaluasi, maka Anda ingin menyelesaikannya dengan menggunakan break atau goto.

Jika Anda memberi tahu loop niat sebenarnya Anda untuk memulai , maka tidak perlu istirahat atau kebagian.

bool alsoThis = true;
for (i = 0; i < 10 && alsoThis; i++)
{    
    for (j = 10; j > 0 && alsoThis; j--)
    {
        if (j == i)
        {
            alsoThis = false;
        }
    }
}

Dalam hal ini, Anda bisa mengubah kode menjadi rutin yang terpisah, dan kemudian hanya returndari loop dalam. Itu akan meniadakan kebutuhan untuk keluar dari lingkaran luar:

bool isBroken() {
    for (i = 0; i < 10; i++)
        for (j = 10; j > 0; j--)
            if (j == i) return true;

    return false;
}

Tidak, saya pikir tidak gotoperlu. Jika Anda menulisnya seperti ini:

bool broken = false;
saved_i = 0;
for (i = 0; i < 10 && !broken; i++)
{
    broken = false;
    for (j = 10; j > 0 && !broken; j--)
    {
        if (j == i)
        {
            broken = true;
            saved_i = i;
        }
    }
}

Memiliki &&!brokenpada kedua loop memungkinkan Anda keluar dari kedua loop ketika i==j.

Bagi saya, pendekatan ini lebih disukai. Kondisi lingkaran sangat jelas: i<10 && !broken.

Versi yang berfungsi dapat dilihat di sini: http://rextester.com/KFMH48414

Kode:

public static void main(String args[])
{
    int i=0;
    int j=0;
    boolean broken = false;
    for (i = 0; i < 10 && !broken; i++)
    {
        broken = false;
        for (j = 10; j > 0 && !broken; j--)
        {
            if (j == i)
            {
                broken = true;
                System.out.println("loop breaks when i==j=="+i);
            }
        }
    }
    System.out.println(i);
    System.out.println(j);
}

Keluaran:

loop terputus ketika saya == j == 1
2
0

Jawaban singkatnya adalah "itu tergantung". Saya menganjurkan untuk memilih tentang keterbacaan dan pemahaman kode Anda. Cara goto mungkin lebih mudah dibaca daripada mengutak-atik kondisi, atau sebaliknya. Anda juga dapat mempertimbangkan prinsip kejutan terkecil, pedoman yang digunakan di toko / proyek dan konsistensi basis kode. Sebagai contoh, goto untuk meninggalkan switch atau untuk penanganan kesalahan adalah praktik umum dalam basis kode kernel Linux. Perhatikan juga bahwa beberapa programmer mungkin mengalami masalah dalam membaca kode Anda (baik dibesarkan dengan mantra "keburukan jahat", atau hanya tidak dipelajari karena guru mereka berpikir demikian) dan beberapa dari mereka bahkan mungkin "menghakimi Anda".

Secara umum, goto yang bergerak lebih jauh dalam fungsi yang sama sering diterima, terutama jika lompatannya tidak terlalu lama. Kasus penggunaan Anda untuk meninggalkan nested loop adalah salah satu contoh goto yang "tidak terlalu jahat".

Dalam kasus Anda, goto sudah cukup untuk perbaikan sehingga terlihat menggoda, tetapi itu bukan perbaikan yang layak melanggar aturan untuk tidak menggunakannya dalam basis kode Anda.

Pikirkan pengulas masa depan Anda: ia harus berpikir, "Apakah orang ini pembuat kode yang buruk atau apakah ini sebenarnya merupakan kasus di mana goto itu sepadan? Biarkan saya mengambil 5 menit untuk memutuskan ini untuk diri saya sendiri atau penelitian pada Internet." Mengapa Anda melakukan itu pada pembuat kode masa depan Anda ketika Anda tidak dapat menggunakan sepenuhnya goto?

Secara umum mentalitas ini berlaku untuk semua kode "buruk" dan bahkan mendefinisikannya: jika berfungsi sekarang, dan bagus dalam hal ini, tetapi menciptakan upaya untuk memverifikasi itu benar, yang di era ini goto akan selalu dilakukan, maka jangan lakukan.

Yang sedang berkata, ya, Anda menghasilkan salah satu kasus yang sedikit lebih sulit. Kamu boleh:

• gunakan struktur kontrol yang lebih kompleks, seperti bendera boolean, untuk keluar dari kedua loop
• letakkan lingkaran dalam di dalam rutinitasnya sendiri (kemungkinan ideal)
• letakkan kedua loop dalam rutin dan kembali alih-alih putus

Sangat sulit bagi saya untuk membuat kasus di mana loop ganda tidak begitu kohesif sehingga seharusnya tidak menjadi rutinitas sendiri.

Ngomong-ngomong, diskusi terbaik tentang ini yang pernah saya lihat adalah Kode Lengkap Steve McConnell . Jika Anda senang memikirkan masalah-masalah ini secara kritis, saya sangat merekomendasikan membaca, bahkan secara langsung meskipun sangat luas.

TLD; DR: Tidak secara spesifik, ya secara umum

Untuk contoh spesifik yang Anda gunakan, saya akan mengatakan tidak karena alasan yang sama seperti yang ditunjukkan oleh banyak orang lain. Anda dapat dengan mudah memperbaiki kode menjadi bentuk yang setara baik yang menghilangkan kebutuhan untuk goto.

Secara umum pelarangan terhadap gotoadalah generalisasi berdasarkan sifat yang dipahami gotodan biaya menggunakannya. Bagian dari rekayasa perangkat lunak adalah membuat keputusan implementasi. Justifikasi dari keputusan-keputusan itu terjadi dengan menimbang biaya terhadap manfaat dan kapan pun manfaatnya melebihi biaya pelaksanaannya dibenarkan. Kontroversi muncul karena penilaian yang berbeda, baik biaya maupun manfaatnya.

Intinya adalah akan selalu ada pengecualian di mana a gotodibenarkan, tetapi hanya untuk beberapa karena penilaian yang berbeda. Sayang sekali banyak insinyur hanya mengecualikan teknik dalam ketidaktahuan sengaja karena mereka membacanya di internet daripada meluangkan waktu untuk memahami mengapa.

Saya rasa kasus ini tidak membenarkan pengecualian, karena ini dapat ditulis sebagai:

def outerLoop(){
    for (i = 0; i < 10; i++) {
        if( broken?(i) )
          return; // broken
    }
}

def broken?(i){
   for (j = 10; j > 0; j--) {
        if (j == i) {
            return true; // broken
        }
   }
   return false; // not broken
}