Aus einer verschachtelten Schleife ausbrechen

Wenn ich eine for-Schleife habe, die in einer anderen verschachtelt ist, wie kann ich dann schnellstmöglich effizient aus beiden Schleifen (innen und außen) herauskommen?

Ich möchte keinen Booleschen Wert verwenden und dann "Gehe zu einer anderen Methode" sagen müssen, sondern nur die erste Codezeile nach der äußeren Schleife ausführen.

Was ist eine schnelle und nette Vorgehensweise?

Ich dachte, dass Ausnahmen nicht billig sind / nur in einem wirklich außergewöhnlichen Zustand usw. geworfen werden sollten. Daher denke ich nicht, dass diese Lösung aus Sicht der Leistung gut wäre.

Ich halte es nicht für richtig, die neueren Funktionen in .NET (anon-Methoden) zu nutzen, um etwas zu tun, das ziemlich grundlegend ist.

Nun, gotoaber das ist hässlich und nicht immer möglich. Sie können die Schleifen auch in eine Methode (oder eine anon-Methode) returneinfügen und verwenden, um zum Hauptcode zurückzukehren.

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

Beachten Sie, dass wir in C # 7 "lokale Funktionen" erhalten sollten, was (Syntax tbd usw.) bedeutet, dass es ungefähr so ​​funktionieren sollte:

// 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 # -Anpassung des Ansatzes, der häufig in C verwendet wird - Wert der Variablen der äußeren Schleife außerhalb der Schleifenbedingungen einstellen (dh für Schleife mit int-Variable INT_MAX -1ist häufig eine gute Wahl):

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    
}

Wie im Code angegeben, breakwird nicht auf magische Weise zur nächsten Iteration der äußeren Schleife gesprungen. Wenn Sie also Code außerhalb der inneren Schleife haben, erfordert dieser Ansatz mehr Überprüfungen. Betrachten Sie in diesem Fall andere Lösungen.

Dieser Ansatz funktioniert mit forund whileSchleifen, funktioniert aber nicht für foreach. Falls foreachSie keinen IEnumeratorCodezugriff auf den versteckten Enumerator haben, können Sie ihn nicht ändern (und selbst wenn Sie keine "MoveToEnd" -Methode haben könnten).

_{Danksagung an die Autoren
i = INT_MAX - 1von Inline-Kommentaren: Vorschlag von Meta
for / foreachKommentar von ygoe .
Richtig IntMaxvon jmbpiano
Bemerkung über Code nach innerer Schleife von blizpasta}

Diese Lösung gilt nicht für C #

Für Personen, die diese Frage über andere Sprachen gefunden haben, ermöglichen Javascript, Java und D gekennzeichnete Pausen und fahren fort :

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

Verwenden Sie einen geeigneten Schutz in der äußeren Schlaufe. Setzen Sie den Schutz in die innere Schlaufe, bevor Sie brechen.

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

Oder noch besser, abstrahieren Sie die innere Schleife in eine Methode und verlassen Sie die äußere Schleife, wenn sie false zurückgibt.

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

    .... some outer loop stuff

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

    ... more outer loop stuff
}

Zitiere mich nicht dazu, aber du könntest goto gebrauchen wie im MSDN vorgeschlagen. Es gibt andere Lösungen, z. B. ein Flag, das in jeder Iteration beider Schleifen überprüft wird. Schließlich könnten Sie eine Ausnahme als wirklich schwere Lösung für Ihr Problem verwenden.

GEHE ZU:

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

Bedingung:

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

Ausnahme:

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

Ist es möglich, die verschachtelte for-Schleife in eine private Methode umzuwandeln? Auf diese Weise können Sie einfach aus der Methode "zurückkehren", um die Schleife zu verlassen.

Es scheint mir, als ob die Leute eine gotoAussage nicht mögen , deshalb hatte ich das Bedürfnis, dies ein wenig zu korrigieren.

Ich glaube, die "Emotionen", die Menschen haben, laufen gotoletztendlich darauf hinaus, Code zu verstehen und (falsche Vorstellungen) über mögliche Auswirkungen auf die Leistung. Bevor ich die Frage beantworte, werde ich daher zunächst einige Details zur Kompilierung erläutern.

Wie wir alle wissen, wird C # zu IL kompiliert, das dann mit einem SSA-Compiler zu Assembler kompiliert wird. Ich werde ein paar Einblicke geben, wie das alles funktioniert, und dann versuchen, die Frage selbst zu beantworten.

Von C # nach IL

Zuerst brauchen wir ein Stück C # -Code. Fangen wir einfach an:

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

Ich werde dies Schritt für Schritt tun, um Ihnen eine gute Vorstellung davon zu geben, was unter der Haube passiert.

Erste Übersetzung: von foreachin die äquivalente forSchleife (Hinweis: Ich verwende hier ein Array, da ich nicht auf Details von IDisposable eingehen möchte - in diesem Fall müsste ich auch eine IEnumerable verwenden):

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

Zweite Übersetzung: das forund breakwird in ein einfacheres Äquivalent übersetzt:

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

Und dritte Übersetzung (dies entspricht dem IL-Code): Wir ändern uns breakund whilein einen Zweig:

    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; 

Während der Compiler diese Aufgaben in einem einzigen Schritt ausführt, erhalten Sie einen Einblick in den Prozess. Der IL-Code, der sich aus dem C # -Programm entwickelt, ist die wörtliche Übersetzung des letzten C # -Codes. Sie können sich hier selbst davon überzeugen: https://dotnetfiddle.net/QaiLRz (klicken Sie auf 'IL anzeigen')

Eine Sache, die Sie hier beobachtet haben, ist, dass der Code während des Prozesses komplexer wird. Der einfachste Weg, dies zu beobachten, ist die Tatsache, dass wir immer mehr Code benötigten, um dasselbe zu erreichen. Man könnte auch argumentieren , dass foreach, for, whileund breaksind eigentlich Kurz Hände goto, die zum Teil wahr ist.

Von IL zu Assembler

Der .NET JIT-Compiler ist ein SSA-Compiler. Ich werde hier nicht auf alle Details des SSA-Formulars eingehen und darauf, wie ein optimierender Compiler erstellt wird. Es ist einfach zu viel, kann aber ein grundlegendes Verständnis darüber vermitteln, was passieren wird. Für ein tieferes Verständnis ist es am besten, sich mit der Optimierung von Compilern zu befassen (ich mag dieses Buch für eine kurze Einführung: http://ssabook.gforge.inria.fr/latest/book.pdf befassen ) und LLVM (llvm.org) .

Jeder optimierende Compiler verlässt sich auf die Tatsache, dass Code einfach ist und vorhersehbaren Mustern folgt . Im Fall von FOR-Schleifen verwenden wir die Graphentheorie, um Zweige zu analysieren und dann Dinge wie Zyklen in unseren Zweigen zu optimieren (z. B. Zweige rückwärts).

Wir haben jetzt jedoch Forward-Zweige, um unsere Schleifen zu implementieren. Wie Sie vielleicht vermutet haben, ist dies tatsächlich einer der ersten Schritte, die die JIT wie folgt beheben wird:

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

Wie Sie sehen können, haben wir jetzt einen Rückwärtszweig, der unsere kleine Schleife ist. Das einzige, was hier noch böse ist, ist der Zweig, mit dem wir aufgrund unserer breakAussage gelandet sind. In einigen Fällen können wir dies auf die gleiche Weise verschieben, in anderen bleibt es jedoch bestehen.

Warum macht der Compiler das? Wenn wir die Schleife abrollen können, können wir sie möglicherweise vektorisieren. Wir könnten sogar beweisen können, dass nur Konstanten hinzugefügt werden, was bedeutet, dass unsere gesamte Schleife in Luft aufgehen könnte. Zusammenfassend lässt sich sagen: Indem wir die Muster vorhersehbar machen (indem wir die Zweige vorhersehbar machen), können wir beweisen, dass bestimmte Bedingungen in unserer Schleife gelten, was bedeutet, dass wir während der JIT-Optimierung zaubern können.

Zweige neigen jedoch dazu, diese schönen vorhersehbaren Muster zu brechen, was Optimierer daher nicht mögen. Brechen Sie, fahren Sie fort, gehen Sie - sie alle beabsichtigen, diese vorhersehbaren Muster zu brechen - und sind daher nicht wirklich "nett".

Sie sollten an dieser Stelle auch erkennen, dass eine einfache Aussage foreachvorhersehbarer ist als eine Reihe von gotoAussagen, die überall vorkommen. In Bezug auf (1) Lesbarkeit und (2) aus Sicht des Optimierers ist dies die bessere Lösung.

Eine weitere erwähnenswerte Sache ist, dass es für die Optimierung von Compilern sehr relevant ist, Register Variablen zuzuweisen (ein Prozess, der als Registerzuweisung bezeichnet wird ). Wie Sie vielleicht wissen, gibt es in Ihrer CPU nur eine begrenzte Anzahl von Registern, und diese sind bei weitem die schnellsten Speicher in Ihrer Hardware. Variablen, die in Code verwendet werden, der sich in der innersten Schleife befindet, erhalten mit größerer Wahrscheinlichkeit ein Register, während Variablen außerhalb Ihrer Schleife weniger wichtig sind (da dieser Code wahrscheinlich weniger getroffen wird).

Hilfe, zu viel Komplexität ... was soll ich tun?

Das Fazit ist, dass Sie immer die Sprachkonstrukte verwenden sollten, die Ihnen zur Verfügung stehen, wodurch normalerweise (implizit) vorhersehbare Muster für Ihren Compiler erstellt werden. Versuchen Sie , seltsame Zweige wenn möglich zu vermeiden (insbesondere: break, continue, gotooder ein returnin der Mitte nichts).

Die gute Nachricht hier ist, dass diese vorhersehbaren Muster sowohl leicht zu lesen (für Menschen) als auch leicht zu erkennen (für Compiler) sind.

Eines dieser Muster heißt SESE und steht für Single Entry Single Exit.

Und jetzt kommen wir zur eigentlichen Frage.

Stellen Sie sich vor, Sie haben so etwas:

// a is a variable.

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

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

Der einfachste Weg, dies zu einem vorhersehbaren Muster zu machen, besteht darin, einfach Folgendes ifvollständig zu eliminieren :

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

In anderen Fällen können Sie die Methode auch in zwei Methoden aufteilen:

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

Temporäre Variablen? Gut, schlecht oder hässlich?

Sie könnten sogar beschließen, einen Booleschen Wert aus der Schleife zurückzugeben (aber ich persönlich bevorzuge das SESE-Formular, da der Compiler es so sieht und ich denke, es ist sauberer zu lesen).

Einige Leute halten es für sauberer, eine temporäre Variable zu verwenden, und schlagen eine Lösung wie diese vor:

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

Ich persönlich bin gegen diesen Ansatz. Sehen Sie sich noch einmal an, wie der Code kompiliert wird. Überlegen Sie nun, was dies mit diesen schönen, vorhersehbaren Mustern bewirken wird. Verstehe?

Richtig, lassen Sie es mich formulieren. Was passieren wird ist das:

• Der Compiler schreibt alles als Zweige aus.
• Als Optimierungsschritt führt der Compiler eine Datenflussanalyse durch, um die seltsame moreVariable zu entfernen, die nur im Kontrollfluss verwendet wird.
• Bei Erfolg wird die Variable moreaus dem Programm entfernt und es bleiben nur Verzweigungen übrig. Diese Zweige werden optimiert, sodass Sie nur einen einzigen Zweig aus der inneren Schleife erhalten.
• Wenn dies nicht erfolgreich ist, wird die Variable moredefinitiv in der innersten Schleife verwendet. Wenn der Compiler sie also nicht optimiert, besteht eine hohe Wahrscheinlichkeit, dass sie einem Register zugewiesen wird (das wertvollen Registerspeicher verbraucht).

Zusammenfassend lässt sich sagen, dass der Optimierer in Ihrem Compiler eine Menge Probleme haben wird, um herauszufinden, dass er morenur für den Kontrollfluss verwendet wird, und ihn im besten Fall in einen einzelnen Zweig außerhalb des äußeren für übersetzt Schleife.

Mit anderen Worten, das beste Szenario ist, dass es das Äquivalent dazu ergibt:

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:

// ...

Meine persönliche Meinung dazu ist ganz einfach: Wenn wir dies die ganze Zeit beabsichtigt haben, lassen Sie uns die Welt sowohl für den Compiler als auch für die Lesbarkeit einfacher machen und das sofort schreiben.

tl; dr:

Endeffekt:

• Verwenden Sie nach Möglichkeit eine einfache Bedingung in Ihrer for-Schleife. Halten Sie sich so weit wie möglich an die Hochsprachenkonstrukte, die Ihnen zur Verfügung stehen.
• Wenn alles fehlschlägt und Sie entweder gotooder bleiben bool more, bevorzugen Sie das erstere.

Berücksichtigen Sie eine Funktion / Methode und verwenden Sie die frühe Rückgabe oder ordnen Sie Ihre Schleifen in eine while-Klausel um. goto / Ausnahmen / was auch immer sind hier sicherlich nicht angebracht.

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

Sie haben nach einer Kombination aus schnell, nett, ohne Verwendung eines Booleschen Werts, ohne Verwendung von goto und C # gefragt. Sie haben alle Möglichkeiten ausgeschlossen, das zu tun, was Sie wollen.

Der schnellste und am wenigsten hässliche Weg ist, ein goto zu verwenden.

Manchmal ist es schön, den Code in seine eigene Funktion zu abstrahieren und dann eine frühe Rückkehr zu verwenden - frühe Rückkehr ist jedoch böse :)

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

Ich habe viele Beispiele gesehen, die "break" verwenden, aber keine, die "continue" verwenden.

Es würde immer noch eine Art Flag in der inneren Schleife erfordern:

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

}

Seit ich vor breakein paar Jahrzehnten zum ersten Mal in C gesehen habe, hat mich dieses Problem geärgert. Ich hatte gehofft, dass eine Sprachverbesserung eine Erweiterung zum Brechen haben würde, die so funktionieren würde:

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.

Ich erinnere mich aus meiner Studienzeit, dass gesagt wurde, es sei mathematisch beweisbar, dass man alles im Code ohne goto machen kann (dh es gibt keine Situation, in der goto die einzige Antwort ist). Also benutze ich niemals goto's (nur meine persönliche Präferenz, was nicht bedeutet, dass ich richtig oder falsch bin)

Um aus verschachtelten Schleifen auszubrechen, mache ich ungefähr so:

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

... ich hoffe das hilft für diejenigen, die mich mögen, sind Anti-Goto "Fanboys" :)

So habe ich es gemacht. Immer noch eine Problemumgehung.

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

Der einfachste Weg, eine Doppelschleife zu beenden, wäre das direkte Beenden der ersten Schleife

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

Schleifen können unter Verwendung benutzerdefinierter Bedingungen in der Schleife unterbrochen werden, um sauberen Code zu erhalten.

    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;   

Mit diesem Code erhalten wir die folgende Ausgabe:

• Externe Schleifeniteration 0
• Iteration der inneren Schleife 0
• Iteration der inneren Schleife 1
• Iteration der inneren Schleife 2
• Iteration der inneren Schleife 3
• Iteration der inneren Schleife 4
• Der Code nach der inneren Schleife wird ausgeführt, wenn Unterbrechungen auftreten

Eine andere Option ist eine selbst aufgerufene anonyme Funktion . Kein goto, keine Bezeichnung, keine neue Variable, kein neuer Funktionsname und eine Zeile kürzer als das Beispiel der anonymen Methode oben.

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

Wirf eine benutzerdefinierte Ausnahme aus, die eine Oterter-Schleife auslöst.

Es funktioniert für for, foreachoder whileoder irgendeine Art von Schleife und jede Sprache , dass Anwendungen try catch exceptionblockieren

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

Wie ich sehe, haben Sie die Antwort akzeptiert, in der die Person auf Ihre Aussage verweist, wo in der modernen Programmierung und in der Expertenmeinung goto ein Killer ist, haben wir es einen Killer in der Programmierung genannt, der einige bestimmte Gründe hat, über die ich hier nicht sprechen werde An diesem Punkt, aber die Lösung Ihrer Frage ist sehr einfach, können Sie in einem solchen Szenario ein Boolesches Flag verwenden, wie ich es in meinem Beispiel demonstrieren werde:

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

einfach und schlicht. :) :)

Hast du dir das breakSchlüsselwort überhaupt angesehen? Oo

Dies ist nur Pseudocode, aber Sie sollten sehen können, was ich meine:

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

Wenn Sie darüber nachdenken break, eine Funktion wie zu seinbreak() , ist der Parameter die Anzahl der Schleifen, aus denen Sie ausbrechen müssen. Da wir uns hier in der dritten Schleife des Codes befinden, können wir aus allen drei ausbrechen.

Handbuch: http://php.net/break

Ich denke, wenn Sie nicht das "Boolesche Ding" machen wollen, ist die einzige Lösung tatsächlich zu werfen. Was du natürlich nicht tun solltest ..!