Keluar dari loop bersarang

Jika saya memiliki for for yang bersarang di dalam yang lain, bagaimana saya bisa secara efisien keluar dari kedua loop (dalam dan luar) dengan cara tercepat yang mungkin?

Saya tidak ingin harus menggunakan boolean dan kemudian harus mengatakan pergi ke metode lain, tetapi hanya untuk mengeksekusi baris kode pertama setelah loop luar.

Apa cara cepat dan menyenangkan untuk melakukan ini?

Saya berpikir bahwa pengecualian tidak murah / hanya boleh dilemparkan dalam kondisi yang benar-benar luar biasa dll. Oleh karena itu saya tidak berpikir solusi ini akan baik dari perspektif kinerja.

Saya tidak merasa itu benar untuk mengambil keuntungan dari fitur-fitur baru di .NET (metode anon) untuk melakukan sesuatu yang sangat mendasar.

Ya, gototapi itu jelek, dan tidak selalu mungkin. Anda juga dapat menempatkan loop ke dalam metode (atau metode anon) dan gunakan returnuntuk keluar kembali ke kode utama.

    // goto
    for (int i = 0; i < 100; i++)
    {
        for (int j = 0; j < 100; j++)
        {
            goto Foo; // yeuck!
        }
    }
Foo:
    Console.WriteLine("Hi");

vs:

// anon-method
Action work = delegate
{
    for (int x = 0; x < 100; x++)
    {
        for (int y = 0; y < 100; y++)
        {
            return; // exits anon-method
        }
    }
};
work(); // execute anon-method
Console.WriteLine("Hi");

Perhatikan bahwa dalam C # 7 kita harus mendapatkan "fungsi lokal", yang (sintaks tbd dll) artinya harus berfungsi seperti:

// local function (declared **inside** another method)
void Work()
{
    for (int x = 0; x < 100; x++)
    {
        for (int y = 0; y < 100; y++)
        {
            return; // exits local function
        }
    }
};
Work(); // execute local function
Console.WriteLine("Hi");

C # adaptasi pendekatan yang sering digunakan dalam C - set nilai variabel luar loop di luar kondisi loop (yaitu untuk loop menggunakan variabel int INT_MAX -1sering merupakan pilihan yang baik):

for (int i = 0; i < 100; i++)
{
    for (int j = 0; j < 100; j++)
    {
        if (exit_condition)
        {
            // cause the outer loop to break:
            // use i = INT_MAX - 1; otherwise i++ == INT_MIN < 100 and loop will continue 
            i = int.MaxValue - 1;
            Console.WriteLine("Hi");
            // break the inner loop
            break;
        }
    }
    // if you have code in outer loop it will execute after break from inner loop    
}

Seperti dicatat dalam kode, kata breaktidak akan secara ajaib melompat ke iterasi berikutnya dari loop luar - jadi jika Anda memiliki kode di luar loop dalam pendekatan ini memerlukan pemeriksaan lebih lanjut. Pertimbangkan solusi lain dalam kasus tersebut.

Pendekatan ini bekerja dengan fordan whileloop tetapi tidak berhasil foreach. Jika foreachAnda tidak memiliki akses kode ke enumerator tersembunyi sehingga Anda tidak dapat mengubahnya (dan bahkan jika Anda IEnumeratortidak memiliki metode "MoveToEnd").

_{Ucapan terima kasih kepada penulis komentar inline:
i = INT_MAX - 1saran oleh Meta
for / foreachkomentar oleh ygoe . Komentar
tepat IntMaxoleh jmbpiano
tentang kode setelah loop dalam oleh blizpasta}

Solusi ini tidak berlaku untuk C #

Untuk orang yang menemukan pertanyaan ini melalui bahasa lain, Javascript, Java, dan D memungkinkan jeda berlabel dan melanjutkan :

outer: while(fn1())
{
   while(fn2())
   {
     if(fn3()) continue outer;
     if(fn4()) break outer;
   }
}

Gunakan pelindung yang cocok di lingkaran luar. Atur pelindung di loop dalam sebelum Anda istirahat.

bool exitedInner = false;

for (int i = 0; i < N && !exitedInner; ++i) {

    .... some outer loop stuff

    for (int j = 0; j < M; ++j) {

        if (sometest) {
            exitedInner = true;
            break;
        }
    }
    if (!exitedInner) {
       ... more outer loop stuff
    }
}

Atau lebih baik lagi, abstraksi loop dalam menjadi metode dan keluar dari loop luar ketika itu kembali palsu.

for (int i = 0; i < N; ++i) {

    .... some outer loop stuff

    if (!doInner(i, N, M)) {
       break;
    }

    ... more outer loop stuff
}

Jangan mengutip saya tentang ini, tetapi Anda bisa menggunakan goto seperti yang disarankan dalam MSDN. Ada solusi lain, seperti termasuk bendera yang diperiksa di setiap iterasi dari kedua loop. Akhirnya Anda bisa menggunakan pengecualian sebagai solusi kelas berat untuk masalah Anda.

PERGI KE:

for ( int i = 0; i < 10; ++i ) {
   for ( int j = 0; j < 10; ++j ) {
      // code
      if ( break_condition ) goto End;
      // more code
   }
}
End: ;

Kondisi:

bool exit = false;
for ( int i = 0; i < 10 && !exit; ++i ) {
   for ( int j = 0; j < 10 && !exit; ++j ) {
      // code
      if ( break_condition ) {
         exit = true;
         break; // or continue
      }
      // more code
   }
}

Pengecualian:

try {
    for ( int i = 0; i < 10 && !exit; ++i ) {
       for ( int j = 0; j < 10 && !exit; ++j ) {
          // code
          if ( break_condition ) {
             throw new Exception()
          }
          // more code
       }
    }
catch ( Exception e ) {}

Apakah mungkin untuk memperbaiki loop yang tersarang untuk menjadi metode pribadi? Dengan begitu Anda bisa 'kembali' keluar dari metode untuk keluar dari loop.

Sepertinya saya suka orang sangat tidak menyukai gotopernyataan, jadi saya merasa perlu untuk meluruskan hal ini sedikit.

Saya percaya 'emosi' yang dimiliki orang pada gotoakhirnya bermuara pada pemahaman kode dan (kesalahpahaman) tentang kemungkinan implikasi kinerja. Sebelum menjawab pertanyaan, karena itu saya akan terlebih dahulu masuk ke beberapa detail tentang bagaimana itu dikompilasi.

Seperti yang kita semua tahu, C # dikompilasi ke IL, yang kemudian dikompilasi ke assembler menggunakan kompiler SSA. Saya akan memberikan sedikit wawasan tentang bagaimana semua ini bekerja, dan kemudian mencoba menjawab pertanyaan itu sendiri.

Dari C # ke IL

Pertama kita membutuhkan sepotong kode C #. Mari kita mulai dari yang sederhana:

foreach (var item in array)
{
    // ... 
    break;
    // ...
}

Saya akan melakukan langkah demi langkah untuk memberi Anda ide bagus tentang apa yang terjadi di bawah tenda.

Terjemahan pertama: dari foreachke forloop setara (Catatan: Saya menggunakan array di sini, karena saya tidak ingin masuk ke rincian IDisposable - dalam hal ini saya juga harus menggunakan IEnumerable):

for (int i=0; i<array.Length; ++i)
{
    var item = array[i];
    // ...
    break;
    // ...
}

Terjemahan kedua: fordan breakditerjemahkan ke dalam padanan yang lebih mudah:

int i=0;
while (i < array.Length)
{
    var item = array[i];
    // ...
    break;
    // ...
    ++i;
}

Dan terjemahan ketiga (ini setara dengan kode IL): kami mengubah breakdan whilemenjadi cabang:

    int i=0; // for initialization

startLoop:
    if (i >= array.Length) // for condition
    {
        goto exitLoop;
    }
    var item = array[i];
    // ...
    goto exitLoop; // break
    // ...
    ++i;           // for post-expression
    goto startLoop; 

Sementara kompiler melakukan hal-hal ini dalam satu langkah, itu memberi Anda wawasan tentang proses. Kode IL yang berevolusi dari program C # adalah terjemahan literal dari kode C # terakhir. Anda dapat melihat sendiri di sini: https://dotnetfiddle.net/QaiLRz (klik 'lihat IL')

Sekarang, satu hal yang Anda amati di sini adalah bahwa selama proses, kode menjadi lebih kompleks. Cara termudah untuk mengamati ini adalah dengan fakta bahwa kami membutuhkan lebih banyak kode untuk menyelesaikan hal yang sama. Anda juga mungkin berpendapat bahwa foreach, for, whiledan breaksebenarnya pendek tangan untuk goto, yang sebagian benar.

Dari IL ke Assembler

Kompiler. NET JIT adalah kompiler SSA. Saya tidak akan membahas semua detail formulir SSA di sini dan cara membuat kompiler yang mengoptimalkan, terlalu banyak, tetapi dapat memberikan pemahaman dasar tentang apa yang akan terjadi. Untuk pemahaman yang lebih dalam, yang terbaik adalah mulai membaca tentang mengoptimalkan kompiler (saya suka buku ini untuk pengantar singkat: http://ssabook.gforge.inria.fr/latest/book.pdf ) dan LLVM (llvm.org) .

Setiap kompiler yang mengoptimalkan bergantung pada fakta bahwa kode itu mudah dan mengikuti pola yang dapat diprediksi . Dalam kasus loop FOR, kami menggunakan teori grafik untuk menganalisis cabang, dan kemudian mengoptimalkan hal-hal seperti cycli di cabang kami (mis. Cabang mundur).

Namun, kami sekarang memiliki cabang ke depan untuk mengimplementasikan loop kami. Seperti yang mungkin sudah Anda duga, ini sebenarnya salah satu langkah pertama yang akan diperbaiki JIT, seperti ini:

    int i=0; // for initialization

    if (i >= array.Length) // for condition
    {
        goto endOfLoop;
    }

startLoop:
    var item = array[i];
    // ...
    goto endOfLoop; // break
    // ...
    ++i;           // for post-expression

    if (i >= array.Length) // for condition
    {
        goto startLoop;
    }

endOfLoop:
    // ...

Seperti yang Anda lihat, kita sekarang memiliki cabang terbelakang, yang merupakan lingkaran kecil kami. Satu-satunya hal yang masih jahat di sini adalah cabang yang kami dapatkan karena breakpernyataan kami . Dalam beberapa kasus, kita dapat memindahkan ini dengan cara yang sama, tetapi dalam kasus lain tetap ada.

Jadi mengapa kompiler melakukan ini? Nah, jika kita bisa membuka gulungannya, kita mungkin bisa mengubahnya. Kita bahkan mungkin dapat membuktikan bahwa hanya ada konstanta yang ditambahkan, yang berarti seluruh loop kita bisa menghilang ke udara tipis. Untuk meringkas: dengan membuat pola-pola yang dapat diprediksi (dengan membuat cabang-cabang dapat diprediksi), kita dapat membuktikan bahwa kondisi-kondisi tertentu bertahan dalam loop kita, yang berarti kita dapat melakukan sihir selama optimasi JIT.

Namun, cabang-cabang cenderung mematahkan pola-pola bagus yang dapat diprediksi itu, yang oleh karenanya merupakan sesuatu yang optimis. Hancurkan, lanjutkan, kebagian - mereka semua berniat untuk menghancurkan pola-pola yang dapat diprediksi ini - dan karenanya tidak benar-benar 'baik'.

Anda juga harus menyadari pada titik ini bahwa yang sederhana foreachlebih dapat diprediksi daripada sekelompok gotopernyataan yang tersebar di semua tempat. Dalam hal (1) keterbacaan dan (2) dari perspektif pengoptimal, keduanya merupakan solusi yang lebih baik.

Hal lain yang patut disebutkan adalah sangat relevan untuk mengoptimalkan kompiler untuk menetapkan register ke variabel (proses yang disebut alokasi register ). Seperti yang mungkin Anda ketahui, hanya ada sejumlah register yang terbatas di CPU Anda dan mereka adalah bagian memori tercepat di perangkat keras Anda. Variabel yang digunakan dalam kode yang berada di loop paling dalam, lebih mungkin untuk mendapatkan register yang ditugaskan, sedangkan variabel di luar loop Anda kurang penting (karena kode ini mungkin lebih sedikit hit).

Bantuan, terlalu banyak kerumitan ... apa yang harus saya lakukan?

Intinya adalah bahwa Anda harus selalu menggunakan konstruksi bahasa yang Anda miliki, yang biasanya (secara implisit) membangun pola yang dapat diprediksi untuk kompiler Anda. Cobalah untuk menghindari cabang aneh jika mungkin (khusus: break, continue, gotoatau returndi tengah-tengah tidak ada).

Kabar baiknya di sini adalah bahwa pola yang dapat diprediksi ini mudah dibaca (untuk manusia) dan mudah dikenali (untuk penyusun).

Salah satu pola itu disebut SESE, yang merupakan kependekan dari Single Entry Single Exit.

Dan sekarang kita sampai pada pertanyaan sebenarnya.

Bayangkan Anda memiliki sesuatu seperti ini:

// a is a variable.

for (int i=0; i<100; ++i) 
{
  for (int j=0; j<100; ++j)
  {
     // ...

     if (i*j > a) 
     {
        // break everything
     }
  }
}

Cara termudah untuk membuat ini menjadi pola yang dapat diprediksi adalah dengan hanya menghilangkan ifsepenuhnya:

int i, j;
for (i=0; i<100 && i*j <= a; ++i) 
{
  for (j=0; j<100 && i*j <= a; ++j)
  {
     // ...
  }
}

Dalam kasus lain, Anda juga dapat membagi metode menjadi 2 metode:

// Outer loop in method 1:

for (i=0; i<100 && processInner(i); ++i) 
{
}

private bool processInner(int i)
{
  int j;
  for (j=0; j<100 && i*j <= a; ++j)
  {
     // ...
  }
  return i*j<=a;
}

Variabel sementara? Baik, buruk, atau jelek?

Anda bahkan mungkin memutuskan untuk mengembalikan boolean dari dalam loop (tapi saya pribadi lebih suka bentuk SESE karena itulah bagaimana kompiler akan melihatnya dan saya pikir lebih bersih untuk membaca).

Beberapa orang berpikir itu lebih bersih untuk menggunakan variabel sementara, dan mengusulkan solusi seperti ini:

bool more = true;
for (int i=0; i<100; ++i) 
{
  for (int j=0; j<100; ++j) 
  {
     // ...
     if (i*j > a) { more = false; break; } // yuck.
     // ...
  }
  if (!more) { break; } // yuck.
  // ...
}
// ...

Saya pribadi menentang pendekatan ini. Lihat lagi bagaimana kode dikompilasi. Sekarang pikirkan apa yang akan dilakukan dengan pola yang bagus dan dapat diprediksi ini. Dapatkan fotonya?

Benar, izinkan saya mengejanya. Apa yang akan terjadi adalah:

• Kompiler akan menuliskan semuanya sebagai cabang.
• Sebagai langkah optimasi, kompiler akan melakukan analisis aliran data dalam upaya untuk menghapus morevariabel aneh yang hanya digunakan dalam aliran kontrol.
• Jika berhasil, variabel moreakan dihilangkan dari program, dan hanya cabang yang tersisa. Cabang-cabang ini akan dioptimalkan, sehingga Anda hanya akan mendapatkan satu cabang saja dari loop dalam.
• Jika tidak berhasil, variabel morepasti digunakan dalam loop paling dalam, jadi jika kompiler tidak akan mengoptimalkannya, ia memiliki peluang besar untuk dialokasikan ke register (yang memakan memori register yang berharga).

Jadi, untuk meringkas: pengoptimal dalam kompiler Anda akan mengalami banyak kesulitan untuk mencari tahu yang morehanya digunakan untuk aliran kontrol, dan dalam skenario kasus terbaik akan menerjemahkannya ke cabang tunggal di luar luar untuk lingkaran.

Dengan kata lain, skenario kasus terbaik adalah bahwa skenario itu akan berakhir dengan yang setara dengan ini:

for (int i=0; i<100; ++i) 
{
  for (int j=0; j<100; ++j)
  {
     // ...
     if (i*j > a) { goto exitLoop; } // perhaps add a comment
     // ...
  }
  // ...
}
exitLoop:

// ...

Pendapat pribadi saya tentang ini cukup sederhana: jika ini yang kami maksudkan selama ini, mari kita buat dunia lebih mudah untuk kompiler dan keterbacaan, dan segera tulis itu.

tl; dr:

Intinya:

• Gunakan kondisi sederhana di loop for Anda jika memungkinkan. Tetap berpegang pada konstruksi tingkat tinggi bahasa yang Anda miliki sebanyak mungkin.
• Jika semuanya gagal dan Anda salah gotoatau bool more, lebih suka yang pertama.

faktor menjadi fungsi / metode dan menggunakan pengembalian awal, atau mengatur ulang loop Anda menjadi klausa sementara. goto / pengecualian / apa pun tentu tidak pantas di sini.

def do_until_equal():
  foreach a:
    foreach b:
      if a==b: return

Anda meminta kombinasi cepat, bagus, tidak menggunakan boolean, tidak menggunakan goto, dan C #. Anda telah mengesampingkan semua cara yang mungkin untuk melakukan apa yang Anda inginkan.

Cara paling cepat dan paling jelek adalah menggunakan goto.

Kadang-kadang bagus untuk mengabstraksi kode ke dalam fungsinya sendiri dan daripada menggunakan pengembalian awal - pengembalian awal itu jahat:)

public void GetIndexOf(Transform transform, out int outX, out int outY)
{
    outX = -1;
    outY = -1;

    for (int x = 0; x < Columns.Length; x++)
    {
        var column = Columns[x];

        for (int y = 0; y < column.Transforms.Length; y++)
        {
            if(column.Transforms[y] == transform)
            {
                outX = x;
                outY = y;

                return;
            }
        }
    }
}

Saya telah melihat banyak contoh yang menggunakan "break" tetapi tidak ada yang menggunakan "continue".

Itu masih akan membutuhkan semacam flag di loop dalam:

while( some_condition )
{
    // outer loop stuff
    ...

    bool get_out = false;
    for(...)
    {
        // inner loop stuff
        ...

        get_out = true;
        break;
    }

    if( get_out )
    {
        some_condition=false;
        continue;
    }

    // more out loop stuff
    ...

}

Sejak saya pertama kali melihat breakdi C beberapa dekade lalu, masalah ini telah membuat saya jengkel. Saya berharap beberapa peningkatan bahasa akan memiliki perpanjangan untuk istirahat yang akan berfungsi sebagai berikut:

break; // our trusty friend, breaks out of current looping construct.
break 2; // breaks out of the current and it's parent looping construct.
break 3; // breaks out of 3 looping constructs.
break all; // totally decimates any looping constructs in force.

Saya ingat dari masa mahasiswa saya bahwa dikatakan secara matematis dapat dibuktikan bahwa Anda dapat melakukan apa pun dalam kode tanpa goto (yaitu tidak ada situasi di mana goto adalah satu-satunya jawaban). Jadi, saya tidak pernah menggunakan goto (hanya preferensi pribadi saya, tidak menyarankan bahwa saya benar atau salah)

Bagaimanapun, untuk keluar dari loop bersarang saya melakukan sesuatu seperti ini:

var isDone = false;
for (var x in collectionX) {
    for (var y in collectionY) {
        for (var z in collectionZ) {
            if (conditionMet) {
                // some code
                isDone = true;
            }
            if (isDone)
                break;
        }
        if (isDone) 
            break;
    }
    if (isDone)
        break;
}

... saya harap itu membantu bagi mereka yang menyukai saya adalah "fanboys" anti-goto :)

Begitulah cara saya melakukannya. Masih ada solusi.

foreach (var substring in substrings) {
  //To be used to break from 1st loop.
  int breaker=1;
  foreach (char c in substring) {
    if (char.IsLetter(c)) {
      Console.WriteLine(line.IndexOf(c));
      \\setting condition to break from 1st loop.
      breaker=9;
      break;
    }
  }
  if (breaker==9) {
    break;
  }
}

Cara termudah untuk mengakhiri loop ganda adalah langsung mengakhiri loop pertama

string TestStr = "The frog jumped over the hill";
char[] KillChar = {'w', 'l'};

for(int i = 0; i < TestStr.Length; i++)
{
    for(int E = 0; E < KillChar.Length; E++)
    {
        if(KillChar[E] == TestStr[i])
        {
            i = TestStr.Length; //Ends First Loop
            break; //Ends Second Loop
        }
    }
}

Loop dapat dipecah menggunakan kondisi khusus dalam loop, memungkinkan untuk memiliki kode bersih.

    static void Main(string[] args)
    {
        bool isBreak = false;
        for (int i = 0; ConditionLoop(isBreak, i, 500); i++)
        {
            Console.WriteLine($"External loop iteration {i}");
            for (int j = 0; ConditionLoop(isBreak, j, 500); j++)
            {
                Console.WriteLine($"Inner loop iteration {j}");

                // This code is only to produce the break.
                if (j > 3)
                {
                    isBreak = true;
                }                  
            }

            Console.WriteLine("The code after the inner loop will be executed when breaks");
        }

        Console.ReadKey();
    }

    private static bool ConditionLoop(bool isBreak, int i, int maxIterations) => i < maxIterations && !isBreak;   

Dengan kode ini kami mendapatkan output berikut:

• Iterasi loop eksternal 0
• Iterasi loop dalam 0
• Iterasi loop dalam 1
• Iterasi loop dalam 2
• Iterasi loop dalam 3
• Iterasi loop dalam 4
• Kode setelah loop dalam akan dieksekusi ketika istirahat

Pilihan lain adalah fungsi anonim yang dipanggil sendiri . Tidak ada goto, tidak ada label, tidak ada variabel baru, tidak ada fungsi-nama baru yang digunakan dan satu baris lebih pendek dari contoh metode anonim di bagian atas.

// self-invoked-anonymous-function
new Action(() =>
{
    for (int x = 0; x < 100; x++)
    {
        for (int y = 0; y < 100; y++)
        {
            return; // exits self invoked lambda expression
        }
    }
})();
Console.WriteLine("Hi");

Lempar pengecualian khusus yang keluar dari loop outter.

Ini berfungsi untuk for, foreachatau whilejenis loop apa saja dan bahasa apa pun yang menggunakan try catch exceptionblok

try 
{
   foreach (object o in list)
   {
      foreach (object another in otherList)
      {
         // ... some stuff here
         if (condition)
         {
            throw new CustomExcpetion();
         }
      }
   }
}
catch (CustomException)
{
   // log 
}

         bool breakInnerLoop=false
        for(int i=0;i<=10;i++)
        {
          for(int J=0;i<=10;i++)
          {
              if(i<=j)
                {
                    breakInnerLoop=true;
                    break;
                }
          }
            if(breakInnerLoop)
            {
            continue
            }
        }

Seperti yang saya lihat Anda menerima jawaban di mana orang merujuk Anda pernyataan goto, di mana dalam pemrograman modern dan dalam pendapat ahli goto adalah pembunuh, kami menyebutnya pembunuh dalam pemrograman yang memiliki beberapa alasan tertentu, yang saya tidak akan membahasnya di sini pada titik ini, tetapi solusi dari pertanyaan Anda sangat sederhana, Anda dapat menggunakan bendera Boolean dalam skenario semacam ini seperti saya akan menunjukkannya dalam contoh saya:

            for (; j < 10; j++)
            {
                //solution
                bool breakme = false;
                for (int k = 1; k < 10; k++)
                {
                   //place the condition where you want to stop it
                    if ()
                    {
                        breakme = true;
                        break;
                    }
                }

                if(breakme)
                    break;
               }

sederhana dan polos. :)

Apakah Anda bahkan melihat breakkata kunci? Oo

Ini hanya kode semu, tetapi Anda harus dapat melihat apa yang saya maksud:

<?php
for(...) {
    while(...) {
        foreach(...) {
            break 3;
        }
    }
}

Jika Anda berpikir tentang breakmenjadi seperti fungsibreak() , maka parameternya adalah jumlah loop yang harus dilepaskan. Karena kita berada di loop ketiga dalam kode di sini, kita dapat keluar dari ketiganya.

Manual: http://php.net/break

Saya pikir kecuali Anda ingin melakukan "hal boolean" satu-satunya solusi sebenarnya adalah melempar. Yang jelas tidak seharusnya kamu lakukan ..!