Виривання з вкладеної петлі

Якщо у мене є цикл for, який вкладений в інший, як я можу швидко вийти з обох циклів (внутрішніх і зовнішніх) якнайшвидшим способом?

Мені не хочеться використовувати булеву систему, а потім потрібно сказати перейти до іншого методу, а скоріше просто виконати перший рядок коду після зовнішнього циклу.

Який швидкий і приємний спосіб зробити це?

Я думав, що винятки не є дешевими / їх слід кидати лише в справді винятковому стані тощо. Отже, я не думаю, що це рішення було б добре з точки зору ефективності.

Я не вважаю, що правильно скористатися новими можливостями в .NET (anon методи), щоб зробити щось досить принципове.

Ну, gotoале це некрасиво, і це не завжди можливо. Ви також можете розмістити петлі в метод (або anon-метод) і використовувати returnдля виходу назад до основного коду.

    // 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 ми повинні отримати "локальні функції", що (синтаксис tbd тощо) означає, що він повинен працювати щось на зразок:

// 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 # адаптація підходу, що часто використовується в C - задане значення змінної зовнішньої петлі поза умовами циклу (тобто для циклу, що використовує змінну int INT_MAX -1, часто є добрим вибором):

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    
}

Як зазначається в коді break , не можна магічно перейти до наступної ітерації зовнішньої петлі - тому якщо у вас є код поза внутрішньої петлі, цей підхід вимагає більше перевірок. Розглянемо інші рішення в такому випадку.

Цей підхід працює з forі whileпетлями , але не працює foreach. У випадку, якщо у foreachвас не буде доступу коду до прихованого нумератора, тому ви не можете його змінити (і навіть якщо у вас IEnumeratorне може бути якогось методу "MoveToEnd").

_{Подяка авторам накреслених коментарів:
i = INT_MAX - 1пропозиція Meta
for / foreachкоментар ygoe .
Правильна IntMaxвід jmbpiano
зауваження про код після внутрішньої петлі бліпастами}

Це рішення не стосується C #

Для людей, які знайшли це питання за допомогою інших мов, Javascript, Java та D дозволяє мітити перерви та продовжує :

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

Використовуйте відповідний щиток у зовнішній петлі. Встановіть оберіг у внутрішню петлю перед тим, як розірватися.

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

Або ще краще, абстрагуйте внутрішній цикл методом і вийдіть із зовнішнього циклу, коли він повернеться хибним.

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

    .... some outer loop stuff

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

    ... more outer loop stuff
}

Не цитуйте мене з цього приводу, але ви можете використовувати goto як пропонується в MSDN. Є й інші рішення, зокрема включити прапор, який перевіряється в кожній ітерації обох циклів. Нарешті, ви можете використати виняток як справді важке рішення вашої проблеми.

ЙТИ ДО:

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

Хвороба:

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

Виняток:

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

Чи можна перефактурувати вкладений цикл в приватний метод? Таким чином, ви можете просто «повернутися» з методу для виходу з циклу.

Мені здається, людям дуже не подобається gotoтвердження, тому я відчув необхідність трохи виправити це.

Я вважаю, що "емоції" людей gotoзрештою зводяться до розуміння коду та (помилок) щодо можливих наслідків для продуктивності. Перш ніж відповісти на запитання, я спершу перейду до деяких деталей того, як воно складено.

Як ми всі знаємо, C # компілюється в IL, який потім компілюється в асемблер за допомогою компілятора SSA. Я дам трохи уявлення про те, як це все працює, а потім спробую відповісти на саме запитання.

Від C # до IL

Спочатку нам потрібен фрагмент коду C #. Почнемо з простого:

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

Я буду робити цей крок за кроком, щоб дати вам гарне уявлення про те, що відбувається під кришкою.

Перший переклад: з foreachеквівалентного forциклу (Примітка. Тут я використовую масив, тому що я не хочу потрапляти в деталі IDisposable - в такому випадку мені також доведеться використовувати IEnumerable):

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

Другий переклад: forі breakперекладається в більш простий еквівалент:

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

І третій переклад (це еквівалент коду IL): ми змінюємо breakі whileв галузі:

    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; 

Хоча компілятор робить це за один крок, він дає вам уявлення про процес. Код IL, який розвивається з програми C #, - це буквальний переклад останнього коду C #. Переконатися в цьому можна тут: https://dotnetfiddle.net/QaiLRz (натисніть "переглянути IL")

Тепер одне, що ви тут помітили, - це те, що під час процесу код стає складнішим. Найпростіший спосіб це спостерігати за тим, що нам потрібно було все більше і більше коду, щоб прискорити те саме. Можна також стверджувати , що foreach, for, whileі breakнасправді є короткими руками для goto, що частково вірно.

Від ІЛ до Асемблера

Компілятор .NET JIT - компілятор SSA. Я не буду вникати в усі деталі форми SSA тут і як створити оптимізуючий компілятор, це занадто багато, але я можу дати базове розуміння того, що буде. Для глибшого розуміння найкраще почати читати про оптимізацію компіляторів (мені подобається ця книга для короткого вступу: http://ssabook.gforge.inria.fr/latest/book.pdf ) та LLVM (llvm.org) .

Кожен оптимізуючий компілятор покладається на те, що код простий і слід передбачуваних моделей . У випадку циклів FOR ми використовуємо теорію графів для аналізу гілок, а потім оптимізуємо такі речі, як цикл у наших гілках (наприклад, гілки назад).

Однак тепер у нас є передні гілки для реалізації наших циклів. Як ви могли здогадатися, це насправді один з перших кроків, який JIT збирається виправити, як це:

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

Як бачите, зараз у нас є відстала гілка, яка є нашою маленькою петлею. Єдине, що тут все-таки противно - це галузь, з якою ми закінчилися завдяки своїй breakзаяві. В деяких випадках ми можемо рухати це тим самим способом, але в інших - це залишитися.

То чому ж компілятор робить це? Ну, якщо ми зможемо розкрутити цикл, ми можемо його векторизувати. Ми навіть можемо довести, що додаються лише константи, а це означає, що вся наша петля може випасти на повітрі. Підводячи підсумок: зробивши шаблони передбачуваними (зробивши гілки передбачуваними), ми можемо довести, що в нашому циклі існують певні умови, а це означає, що ми можемо робити магію під час оптимізації JIT.

Однак гілки, як правило, ламають ті приємні передбачувані зразки, що є чимось оптимізатором. Перервайтеся, продовжуйте, переходьте - всі вони мають намір порушити ці передбачувані закономірності - і тому насправді не «приємні».

На цьому етапі ви також повинні усвідомити, що просте foreachє більш передбачуваним, ніж купа gotoтверджень, які проходять повсюдно. Що стосується (1) читабельності та (2) з точки зору оптимізатора, це і краще рішення.

Ще одна річ, яку варто згадати, це те, що це дуже актуально для оптимізації компіляторів для призначення регістрів змінним (процес, який називається розподілом регістрів ). Як ви можете знати, у вашому процесорі є лише обмежена кількість реєстрів, і це далеко не найшвидший об'єм пам'яті у вашому обладнання. Змінні, що використовуються в коді, що знаходиться в самому внутрішньому циклі, швидше отримують присвоєний реєстр, тоді як змінні за межами вашого циклу мають менш важливе значення (тому що цей код, ймовірно, менший).

Допомога, занадто велика складність ... що мені робити?

Суть полягає в тому, що ви завжди повинні використовувати мовні конструкції, які у вас є, що зазвичай (неявно) будують передбачувані шаблони для вашого компілятора. Намагайтеся уникати дивних гілок , якщо це можливо ( в Зокрема: break, continue, gotoабо returnв середині нічого).

Хороша новина тут полягає в тому, що ці передбачувані зразки є легкими для читання (для людей) та легкими для помічення (для компіляторів).

Один із таких шаблонів називається SESE, який означає "Single Entry Single Exit".

І тепер ми переходимо до реального питання.

Уявіть, що у вас є щось подібне:

// a is a variable.

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

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

Найпростіший спосіб зробити цю передбачувану схему - просто усунути ifповністю:

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

В інших випадках ви також можете розділити метод на 2 способи:

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

Тимчасові змінні? Хороший, поганий чи потворний?

Ви навіть можете вирішити повернути булевий цикл із циклу (але я особисто віддаю перевагу формі SESE, тому що компілятор це побачить, і я думаю, що це чистіше читати).

Деякі люди вважають, що використовувати тимчасову змінну чистіше, і пропонують таке рішення:

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

Я особисто проти такого підходу. Подивіться ще раз на те, як складається код. Тепер подумайте, що це буде робити з цими приємними передбачуваними зразками. Отримати картину?

Правильно, дозвольте мені прописати це. Що станеться, це те, що:

• Компілятор випише все як гілки.
• В якості кроку оптимізації компілятор зробить аналіз потоку даних, намагаючись видалити дивну moreзмінну, яка буває використана лише в керуючому потоці.
• У разі успіху змінна moreбуде видалена з програми, а залишаються лише гілки. Ці гілки будуть оптимізовані, тому ви отримаєте лише одну гілку із внутрішньої петлі.
• Якщо невдало, змінна more, безумовно, використовується в самому внутрішньому циклі, тому якщо компілятор не оптимізує її, вона має високі шанси бути віднесеною до реєстру (що з'їдає цінну пам'ять реєстру).

Отже, підсумовуючи: оптимізатор у вашому компіляторі потрапить у пекло багато проблем, щоб зрозуміти, що moreвін використовується лише для керуючого потоку, і в кращому випадку сценарій переведе його на одну гілку за межами зовнішньої для петля.

Іншими словами, найкращим сценарієм є те, що він закінчиться еквівалентом цього:

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:

// ...

Моя особиста думка з цього приводу досить проста: якщо це те, що ми мали намір весь час, давайте полегшимо світ як для компілятора, так і для читання, і запишемо це відразу.

tl; dr:

Нижня лінія:

• Якщо можливо, використовуйте просту умову у своєму циклі. Дотримуйтесь якомога більше мовних конструкцій, які є у вас в розпорядженні.
• Якщо все виходить з ладу, і ви залишаєтесь з одним gotoабо bool more, віддайте перевагу першому.

фактор на функцію / метод і використовувати раннє повернення або переставити петлі в пункт-час. goto / винятки / що завгодно, звичайно, тут не підходить.

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

Ви попросили поєднати швидке, приємне, без булевого використання, без використання goto та C #. Ви виключили всі можливі способи робити те, що ви хочете.

Найшвидший і найменш негарний спосіб - використовувати гото.

Іноді приємно абстрагувати код на його власну функцію, а потім використовувати раннє повернення - хоча раннє повернення є злим:)

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

Я бачив багато прикладів, які використовують "break", але жоден, який використовує "продовжити".

Це все-таки вимагатиме певного прапора у внутрішньому циклі:

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 кілька років тому, ця проблема хвилювала мене. Я сподівався, що деяке вдосконалення мови матиме розширення, яке може працювати таким чином:

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.

З моїх студентських днів я пам’ятаю, що з математичних доказів можна сказати, що ви можете робити що-небудь у коді без goto (тобто немає ситуації, коли goto є єдиною відповіддю). Отже, я ніколи не використовую Goto (просто мої особисті переваги, не підказуючи, що я правильно чи неправильно)

У будь-якому випадку, щоб вирватися з вкладених циклів, я роблю щось подібне:

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

... сподіваюся, що для тих, хто подобається мені, є анти-гото "фанбої" :)

Ось як я це зробив. Досі вирішення.

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

Найпростішим способом закінчити подвійну петлю було б безпосередньо закінчення першого циклу

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

Петлі можуть бути розірвані, використовуючи власні умови в циклі, дозволяючи мати чистий код.

    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;   

За допомогою цього коду ми отримуємо такий вихід:

• Ітерація зовнішньої петлі 0
• Ітерація внутрішньої петлі 0
• Ітерація внутрішньої петлі 1
• Ітерація внутрішньої петлі 2
• Ітерація внутрішньої петлі 3
• Ітерація внутрішньої петлі 4
• Код після внутрішнього циклу буде виконуватися при перервах

Іншим варіантом є анонімна функція, яка самостійно викликається . Ні goto, ні мітка, ні нова змінна, ні нове ім'я функції не використовується, а на один рядок коротший, ніж приклад анонімного методу вгорі.

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

Закиньте спеціальний виняток, який виходить із зовнішнього циклу.

Він працює for, foreachабо whileчи будь-який вид циклу і будь-яку мову , який використовує try catch exceptionблок

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

Як я бачу, ви прийняли відповідь, в якій людина посилається на висловлення goto, де в сучасному програмуванні та на думку експерта goto є вбивцею, ми назвали це вбивцею в програмуванні, яке має певні причини, і я не буду це обговорювати тут на даний момент, але рішення вашого питання дуже просте, ви можете використовувати булевий прапор у такому сценарії, як я продемонструю це у своєму прикладі:

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

простий і простий. :)

Ви навіть переглянули breakключове слово? Оо

Це просто псевдо-код, але ви повинні мати можливість бачити, що я маю на увазі:

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

Якщо ви думаєте про breakте, як функція на зразок break(), то її параметром буде кількість циклів, які потрібно вирвати. Оскільки ми знаходимося в третьому циклі коду тут, ми можемо вирватися з усіх трьох.

Посібник: http://php.net/break

Я думаю, якщо ви не хочете робити "булеву справу", єдине рішення - насправді кинути. Що ви, очевидно, не повинні робити ..!