İç içe bir döngüden kopma

Başka bir içine yerleştirilmiş bir for döngüsü varsa, her iki döngüden (iç ve dış) mümkün olan en hızlı şekilde nasıl verimli bir şekilde çıkabilirim?

Bir boolean kullanmak ve sonra başka bir yönteme gitmek söylemek zorunda değil, sadece dış döngü sonra kodun ilk satırını yürütmek istemiyorum.

Bunu yapmanın hızlı ve güzel bir yolu nedir?

İstisnaların ucuz olmadığını / sadece istisnai bir durumda vb. Atılması gerektiğini düşünüyordum. Dolayısıyla bu çözümün performans açısından iyi olacağını düşünmüyorum.

Ben oldukça temel bir şey yapmak için .NET (anon yöntemleri) yeni özelliklerinden yararlanmak doğru olduğunu düşünmüyorum.

Şey, gotoama bu çirkin ve her zaman mümkün değil. Ayrıca döngüleri bir yönteme (veya anon yöntemine) yerleştirebilir ve returnana koda geri dönmek için kullanabilirsiniz .

    // 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");

C # 7'de (yerel sözdizimi) elde etmemiz gerektiğini unutmayın;

// 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");

Dış döngü değişkeninin döngü koşullarının dışındaki C - set değerinde sıklıkla kullanılan yaklaşımın C # uyarlaması (yani int değişkenini kullanan döngü INT_MAX -1için genellikle iyi bir seçimdir):

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    
}

Kodda notun dediği gibi breaksihirli bir şekilde dış halkanın bir sonraki yinelemesine atlamayacaktır - bu yüzden iç halkanın dışında kodunuz varsa bu yaklaşım daha fazla kontrol gerektirir. Bu durumda diğer çözümleri düşünün.

Bu yaklaşım ile çalışır forve whiledöngüler ancak işe yaramaz foreach. Durumunda foreach(eğer olabilseydi bile ve bunu değiştiremezsiniz böylece size gizli numaralandırıcıya kod erişemez IEnumeratorbazı "MoveToEnd" yöntemine sahip değildir).

_{İnlined comments' yazarlara Teşekkür:
i = INT_MAX - 1tarafından öneri Meta
for / foreachtarafından comment ygoe .
Uygun IntMaxtarafından jmbpiano
ile iç döngü sonra kodu ile ilgili sözler blizpasta}

Bu çözüm C # için geçerli değildir

Bu soruyu diğer diller aracılığıyla bulan kullanıcılar için Javascript, Java ve D etiketli molalara izin verir ve devam eder :

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

Dış halkada uygun bir koruyucu kullanın. Kırmadan önce koruyucuyu iç halka içine yerleştirin.

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

Ya da daha iyisi, iç döngüyü bir yönteme soyutlayın ve false döndürdüğünde dış döngüden çıkın.

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

    .... some outer loop stuff

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

    ... more outer loop stuff
}

Bu konuda bana alıntı yapma, ama MSDN'de önerildiği gibi goto kullanabilirsiniz . Her iki döngünün her yinelemesinde kontrol edilen bir bayrak dahil olmak üzere başka çözümler de vardır. Son olarak, bir istisnayı probleminize gerçekten ağır bir çözüm olarak kullanabilirsiniz.

GOTO:

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

Durum:

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

İstisna:

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

Nested for loop'u özel bir yönteme dönüştürmek mümkün mü? Bu şekilde, döngüden çıkmak için yöntemden 'geri' dönebilirsiniz.

Bana öyle geliyor ki insanlar bir gotoifadeden çok hoşlanmıyorlar , bu yüzden bunu biraz düzeltmem gerektiğini hissettim.

İnsanların gotoeninde sonunda sahip oldukları 'duyguların' kodun anlaşılmasıyla ve olası performans sonuçlarıyla ilgili (yanlış anlamalar) kaybolacağına inanıyorum . Bu soruyu cevaplamadan önce, nasıl derlendiğine dair bazı ayrıntılara gireceğim.

Hepimizin bildiği gibi, C # IL'ye derlenir ve daha sonra bir SSA derleyicisi kullanarak montajcıya derlenir. Tüm bunların nasıl çalıştığı hakkında biraz bilgi vereceğim ve ardından sorunun kendisine cevap vermeye çalışacağım.

C # 'dan IL' ye

İlk önce bir parça C # koduna ihtiyacımız var. Basit başlayalım:

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

Kaputun altında neler olduğu hakkında iyi bir fikir vermek için bunu adım adım yapacağım.

İlk çeviri: den foreacheşdeğer fordöngüye (Not: Burada bir dizi kullanıyorum, çünkü IDisposable'ın ayrıntılarına girmek istemiyorum - bu durumda da bir IEnumerable kullanmak zorunda kalacağım):

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

İkinci çeviri: forve break, daha kolay bir karşılığıdır:

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

Ve üçüncü çeviri (bu IL kod eşdeğerdir): Biz değiştirmek breakve whilebir şube haline:

    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; 

Derleyici bunları tek bir adımda gerçekleştirirken, süreç hakkında size fikir verir. C # programından gelişen IL kodu , son C # kodunun gerçek çevirisidir . Burada kendiniz görebilirsiniz: https://dotnetfiddle.net/QaiLRz ('IL'yi görüntüle' bağlantısını tıklayın)

Şimdi, burada gözlemlediğiniz bir şey, işlem sırasında kodun daha karmaşık hale gelmesidir. Bunu gözlemlemenin en kolay yolu, aynı şeyi kabul etmek için gittikçe daha fazla koda ihtiyaç duymamızdır. Ayrıca iddia edebilir foreach, for, whileve breakaslında kısa ellerdir gotokısmen doğru olan.

IL'den Assembler'a

.NET JIT derleyicisi bir SSA derleyicisidir. Burada SSA formunun tüm ayrıntılarına ve optimize edici bir derleyicinin nasıl oluşturulacağına girmeyeceğim, çok fazla, ancak ne olacağı hakkında temel bir anlayış verebilir. Daha derin bir anlayış için, derleyicileri optimize etmeye okumaya başlamak en iyisidir (kısa bir giriş için bu kitabı beğendim: http://ssabook.gforge.inria.fr/latest/book.pdf ) ve LLVM (llvm.org) .

Her optimize edici derleyici, kodun kolay olduğu ve öngörülebilir kalıpları takip ettiği gerçeğine dayanır . FOR döngüleri durumunda, dalları analiz etmek için grafik teorisini kullanırız ve sonra da dallarımızdaki cycli gibi şeyleri optimize ederiz (örn. Geriye doğru dallar).

Ancak, şimdi döngülerimizi uygulamak için ileri şubelerimiz var. Tahmin edebileceğiniz gibi, bu aslında JIT'in düzelteceği ilk adımlardan biridir, şöyle:

    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:
    // ...

Gördüğünüz gibi, artık geri döngümüz var, bu da bizim küçük döngümüz. Burada hala kötü olan tek şey, breakaçıklamamız nedeniyle sonuçta bulunduğumuz şubedir. Bazı durumlarda, bunu aynı şekilde hareket ettirebiliriz, ancak bazılarında kalmak için oradadır.

Peki derleyici bunu neden yapıyor? Döngüyü çözebilirsek, vektörleştirebiliriz. Sadece sabitlerin eklendiğini bile kanıtlayabiliriz, yani tüm döngümüz ince havaya kaybolabilir. Özetlemek gerekirse: paternleri öngörülebilir hale getirerek (dalları öngörülebilir hale getirerek), döngümüzde belirli koşulların geçerli olduğunu kanıtlayabiliriz, yani JIT optimizasyonu sırasında sihir yapabiliriz.

Bununla birlikte, dallar bu güzel öngörülebilir kalıpları kırma eğilimindedir, bu da optimize edicilerdir ve bu nedenle hoşnutsuz bir şeydir. Kır, devam et, git - hepsi bu öngörülebilir kalıpları kırmayı planlıyor - ve bu yüzden gerçekten 'hoş' değiller.

Bu noktada, bir basitliğin her yere yayılan foreachbir grup gotoifadeden daha öngörülebilir olduğunu da fark etmelisiniz . Optimize edici bakış açısından (1) okunabilirlik ve (2) açısından, hem daha iyi çözümdür.

Bahsetmeye değer başka bir şey de, derleyicileri değişkenlere kayıt atamak için optimize etmenin çok alakalı olmasıdır ( kayıt tahsisi adı verilen bir süreç ). Bildiğiniz gibi, CPU'nuzda sadece sınırlı sayıda kayıt vardır ve bunlar donanımınızdaki en hızlı bellek parçalarıdır. En içteki döngüde kodda kullanılan değişkenlerin bir kayıt atanması daha olasıdır, ancak döngünüzün dışındaki değişkenler daha az önemlidir (çünkü bu kod muhtemelen daha az isabetlidir).

Yardım, çok fazla karmaşıklık ... ne yapmalıyım?

Sonuç olarak, her zaman emrinizde olan dil yapılarını kullanmalısınız, bu da derleyiciniz için genellikle (dolaylı olarak) tahmin edilebilir kalıplar oluşturur. (: Özellikle mümkünse garip dalları kaçının break, continue, gotoya da returnhiçbir şey ortasında).

Buradaki iyi haber şu ki bu öngörülebilir kalıplar hem insanlar için hem de okunması kolay (derleyiciler için).

Bu kalıplardan birine SESE denir ve Tek Girişli Tek Çıkış anlamına gelir.

Ve şimdi gerçek soruya geçiyoruz.

Bunun gibi bir şeyiniz olduğunu düşünün:

// a is a variable.

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

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

Bunu öngörülebilir bir desen haline getirmenin en kolay yolu, iftamamen ortadan kaldırmaktır :

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

Diğer durumlarda yöntemi de 2 yönteme bölebilirsiniz:

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

Geçici değişkenler? İyi, kötü ya da çirkin mi?

Hatta döngü içinden bir boolean döndürmeye karar verebilirsiniz (ama ben şahsen SESE formunu tercih ederim çünkü derleyici bunu görecek ve okumak daha temiz olduğunu düşünüyorum).

Bazı insanlar geçici bir değişken kullanmanın daha temiz olduğunu düşünüyor ve böyle bir çözüm öneriyor:

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

Ben şahsen bu yaklaşıma karşıyım. Kodun nasıl derlendiğine tekrar bakın. Şimdi bunun bu güzel, öngörülebilir kalıplarla ne yapacağını düşünün. Resmi al?

Doğru, heceleyelim. Ne olacak:

• Derleyici her şeyi dal olarak yazacaktır.
• Bir optimizasyon adımı olarak, derleyici moresadece kontrol akışında kullanılan garip değişkeni ortadan kaldırmak için veri akışı analizi yapacaktır .
• Başarılı olursa, değişken moreprogramdan kaldırılır ve yalnızca dallar kalır. Bu dallar optimize edilecek, böylece iç döngüden sadece tek bir dal alacaksınız.
• Eğer başarısız olursa, değişken moreen içteki döngüde kesinlikle kullanılır, bu nedenle derleyici onu optimize etmezse, bir kayda tahsis etme şansı yüksektir (değerli kayıt hafızasını tüketir).

Özetlemek gerekirse: derleyicinizdeki optimizer more, yalnızca kontrol akışı için kullanıldığını anlamak için çok fazla sorun yaşayacaktır ve en iyi durumda senaryo , onu dış için tek bir dala çevirecektir. döngü.

Başka bir deyişle, en iyi senaryo, bunun eşdeğeri ile sonuçlanacağı yönündedir:

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:

// ...

Bununla ilgili kişisel düşüncem oldukça basit: eğer başından beri istediğimiz buysa, dünyayı hem derleyici hem de okunabilirlik için kolaylaştıralım ve hemen yazalım.

tl; dr:

Sonuç olarak:

• Mümkünse for döngüsü içinde basit bir koşul kullanın. Mümkün olduğunca üst düzey dil yapılarına bağlı kalın.
• Her şey başarısız olursa ve ya sol ediyorsanız gotoveya bool moreeski tercih ederler.

bir işleve / yönteme dönüştürün ve erken dönüş kullanın veya döngülerinizi bir süre yan tümcesinde yeniden düzenleyin. goto / istisnalar / burada kesinlikle uygun olmayan ne varsa.

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

Hızlı, güzel, boole kullanmama, goto kullanmama ve C # kombinasyonunu istediniz. İstediğinizi yapmanın tüm olası yollarını dışladınız.

En hızlı ve en az çirkin yol bir goto kullanmaktır.

Bazen kodu kendi işlevine soyutlamak güzel ve erken bir dönüş kullanmaktan daha erken - erken dönüşler kötüdür:)

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

Ben "break" kullanan bir çok örnek gördüm ama "devam" kullanan hiçbiri.

İç döngüde hala bir tür bayrak gerekir:

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
    ...

}

breakC'de birkaç on yıl önce ilk gördüğümden beri , bu sorun beni sinirlendirdi. Bazı dil geliştirme, böylece işe yarayacak bir uzantısı olacak umuyordum:

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.

Öğrenci günlerimden, bir goto olmadan kodda herhangi bir şey yapabileceğinizin matematiksel olarak kanıtlanabilir olduğunu hatırlıyorum (yani, goto'nun tek cevap olduğu bir durum yok). Yani, asla goto'ları kullanmam (sadece kişisel tercihim, doğru ya da yanlış olduğumu düşündürmüyorum)

Her neyse, iç içe döngülerden kurtulmak için şöyle bir şey yapıyorum:

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

... umarım bu benim gibi olanlar için anti-goto "fanboylar" yardımcı olur :)

Ben böyle yaptım. Hala bir çözüm.

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

Çift döngüyü sonlandırmanın en kolay yolu doğrudan ilk döngüyü bitirmek olacaktır

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

Döngüler, döngüdeki özel koşullar kullanılarak kırılabilir, böylece temiz kod elde edilir.

    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;   

Bu kod ile aşağıdaki çıktıyı elde ederiz:

• Harici döngü yineleme 0
• İç döngü yinelemesi 0
• İç döngü yinelemesi 1
• İç döngü yinelemesi 2
• İç döngü yinelemesi 3
• İç döngü yinelemesi 4
• İç döngüden sonraki kod, kesildiğinde yürütülür

Diğer bir seçenek, kendi kendine çağrılan anonim bir işlevdir . Git yok, etiket yok, yeni değişken yok, yeni işlev adı yok ve üstteki anonim yöntem örneğinden bir satır daha kısa .

// 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");

Çıkış döngüsü dışına çıkan özel bir istisna atın.

Şunun için çalışır for, foreachya da whiledöngü her türlü ve herhangi bir dil olduğunu veya kullandığı 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
            }
        }

Gördüğüm gibi, kişinin sizi ifade ettiği ifadeyi kabul ettiğinizi, modern programlamada ve uzman görüşünde goto'nun bir katil olduğu, bunu programlamada bazı nedenleri olan bir katil olarak adlandırdık, burada tartışmayacağım bu noktada, ancak sorunuzun çözümü çok basit, bu tür bir senaryoda bir Boole bayrağı kullanabilirsiniz, örneğin örneğimde göstereceğim gibi:

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

basit ve sade. :)

Hatta baktın mı breakanahtar kelime? Oo

Bu sadece sözde kod, ama ne demek istediğimi görebilmelisiniz:

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

breakGibi bir işlev olmayı düşünüyorsanızbreak() , parametre değiştirilecek döngü sayısı olacaktır. Buradaki kodun üçüncü döngüsünde olduğumuz için, üçünden de ayrılabiliriz.

Manuel: http://php.net/break

Bence "boolean şeyi" yapmak istemiyorsanız tek çözüm aslında atmaktır. Açıkçası yapmamalısın ..!