Який найкращий спосіб перерватися з вкладених циклів у JavaScript?

Який найкращий спосіб перерватися з вкладених циклів у Javascript?

//Write the links to the page.
for (var x = 0; x < Args.length; x++)
{
   for (var Heading in Navigation.Headings)
   {
      for (var Item in Navigation.Headings[Heading])
      {
         if (Args[x] == Navigation.Headings[Heading][Item].Name)
         {
            document.write("<a href=\"" 
               + Navigation.Headings[Heading][Item].URL + "\">" 
               + Navigation.Headings[Heading][Item].Name + "</a> : ");
            break; // <---HERE, I need to break out of two loops.
         }
      }
   }
}

Так само, як Perl,

loop1:
    for (var i in set1) {
loop2:
        for (var j in set2) {
loop3:
            for (var k in set3) {
                break loop2;  // breaks out of loop3 and loop2
            }
        }
    }

як визначено в розділі 12.12 EMCA-262. [Документи MDN]

На відміну від C, ці мітки можуть використовуватися лише для, continueа breakу Javascript немає goto.

Заверніть це у функції, а потім просто return.

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

for (var x = Set1.length; x > 0; x--)
{
   for (var y = Set2.length; y > 0; y--)
   {
      for (var z = Set3.length; z > 0; z--)
      {
          z = y = -1; // terminates second loop
          // z = y = x = -1; // terminate first loop
      }
   }
}

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

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

var a, b, abort = false;
for (a = 0; a < 10 && !abort; a++) {
    for (b = 0; b < 10 && !abort; b++) {
        if (condition) {
            doSomeThing();
            abort = true;
        }
    }
}

var str = "";
for (var x = 0; x < 3; x++) {
    (function() {  // here's an anonymous function
        for (var y = 0; y < 3; y++) {
            for (var z = 0; z < 3; z++) {
                // you have access to 'x' because of closures
                str += "x=" + x + "  y=" + y + "  z=" + z + "<br />";
                if (x == z && z == 2) {
                    return;
                }
            }
        }
    })();  // here, you execute your anonymous function
}

Як це? :)

Досить просто:

var a = [1, 2, 3];
var b = [4, 5, 6];
var breakCheck1 = false;

for (var i in a) {
    for (var j in b) {
        breakCheck1 = true;
        break;
    }
    if (breakCheck1) break;
}

Ось п’ять способів виривання вкладених циклів у JavaScript:

1) Встановіть цикл батьків (ів) до кінця

for (i = 0; i < 5; i++)
{
    for (j = 0; j < 5; j++)
    {
        if (j === 2)
        {
            i = 5;
            break;
        }
    }
}

2) Використовуйте етикетку

exit_loops:
for (i = 0; i < 5; i++)
{
    for (j = 0; j < 5; j++)
    {
        if (j === 2)
            break exit_loops;
    }
}

3) Використовуйте змінну

var exit_loops = false;
for (i = 0; i < 5; i++)
{
    for (j = 0; j < 5; j++)
    {
        if (j === 2)
        {
            exit_loops = true;
            break;
        }
    }
    if (exit_loops)
        break;
}

4) Використовуйте функцію самовиконання

(function()
{
    for (i = 0; i < 5; i++)
    {
        for (j = 0; j < 5; j++)
        {
             if (j === 2)
                 return;
        }
    }
})();

5) Використовуйте звичайну функцію

function nested_loops()
{
    for (i = 0; i < 5; i++)
    {
        for (j = 0; j < 5; j++)
        {
             if (j === 2)
                 return;
        }
    }
}
nested_loops();

Як щодо того, щоб взагалі не використовувати перерв, не вимагати відміни прапорців та додаткових перевірок стану. Ця версія просто виконує змінні циклу (робить їх Number.MAX_VALUE), коли виконується умова, і змушує всі петлі закінчуватися елегантно.

// No breaks needed
for (var i = 0; i < 10; i++) {
  for (var j = 0; j < 10; j++) {
    if (condition) {
      console.log("condition met");
      i = j = Number.MAX_VALUE; // Blast the loop variables
    }
  }
}

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

Ще один приклад:

// No breaks needed
for (var i = 0; i < 89; i++) {
  for (var j = 0; j < 1002; j++) {
    for (var k = 0; k < 16; k++) {
      for (var l = 0; l < 2382; l++) {
        if (condition) {
          console.log("condition met");
          i = j = k = l = Number.MAX_VALUE; // Blast the loop variables
        }
      }
    }
  }
}

Як щодо просування петель до їх кінцевих меж

    for(var a=0; a<data_a.length; a++){
       for(var b=0; b<data_b.length; b++){
           for(var c=0; c<data_c.length; c++){
              for(var d=0; d<data_d.length; d++){
                 a =  data_a.length;
                 b =  data_b.length;
                 c =  data_b.length;
                 d =  data_d.length;
            }
         }
       }
     }

Якщо ви використовуєте Coffeescript, є зручне ключове слово "зробити", яке полегшує визначення та негайне виконання анонімної функції:

do ->
  for a in first_loop
    for b in second_loop
      if condition(...)
        return

... так що ви можете просто використовувати "return", щоб вийти з циклів.

Я думав, що я покажу функціонально-програмовий підхід. Ви можете вибивати з вкладених функцій Array.prototype.some () та / або Array.prototype.every (), як у моїх рішеннях. Додатковою перевагою цього підходу є те, що Object.keys()перераховується лише власні перелічені властивості об'єкта, тоді як «цикл для входу перераховує також властивості в ланцюзі прототипу». .

Близьке до рішення ОП:

    Args.forEach(function (arg) {
        // This guard is not necessary,
        // since writing an empty string to document would not change it.
        if (!getAnchorTag(arg))
            return;

        document.write(getAnchorTag(arg));
    });

    function getAnchorTag (name) {
        var res = '';

        Object.keys(Navigation.Headings).some(function (Heading) {
            return Object.keys(Navigation.Headings[Heading]).some(function (Item) {
                if (name == Navigation.Headings[Heading][Item].Name) {
                    res = ("<a href=\""
                                 + Navigation.Headings[Heading][Item].URL + "\">"
                                 + Navigation.Headings[Heading][Item].Name + "</a> : ");
                    return true;
                }
            });
        });

        return res;
    }

Рішення, що зменшує ітерацію над заголовками / елементами:

    var remainingArgs = Args.slice(0);

    Object.keys(Navigation.Headings).some(function (Heading) {
        return Object.keys(Navigation.Headings[Heading]).some(function (Item) {
            var i = remainingArgs.indexOf(Navigation.Headings[Heading][Item].Name);

            if (i === -1)
                return;

            document.write("<a href=\""
                                         + Navigation.Headings[Heading][Item].URL + "\">"
                                         + Navigation.Headings[Heading][Item].Name + "</a> : ");
            remainingArgs.splice(i, 1);

            if (remainingArgs.length === 0)
                return true;
            }
        });
    });

Раніше згадувалося swilliams , але з прикладом нижче (Javascript):

// Function wrapping inner for loop
function CriteriaMatch(record, criteria) {
  for (var k in criteria) {
    if (!(k in record))
      return false;

    if (record[k] != criteria[k])
      return false;
  }

  return true;
}

// Outer for loop implementing continue if inner for loop returns false
var result = [];

for (var i = 0; i < _table.length; i++) {
  var r = _table[i];

  if (!CriteriaMatch(r[i], criteria))
    continue;

  result.add(r);
}

Хм, привіт до 10-річної вечірки?

Чому б не поставити собі якусь умову?

var condition = true
for (var i = 0 ; i < Args.length && condition ; i++) {
    for (var j = 0 ; j < Args[i].length && condition ; j++) {
        if (Args[i].obj[j] == "[condition]") {
            condition = false
        }
    }
}

Так, ти зупиняєшся, коли хочеш

У моєму випадку, використовуючи Typescript, ми можемо використовувати деякі (), які проходять через масив і зупиняються, коли виконується умова. Отже, мій код стає таким:

Args.some((listObj) => {
    return listObj.some((obj) => {
        return !(obj == "[condition]")
    })
})

Так, цикл зупиняється відразу після виконання умови

Нагадування: Цей код виконується в TypeScript

XXX.Validation = function() {
    var ok = false;
loop:
    do {
        for (...) {
            while (...) {
                if (...) {
                    break loop; // Exist the outermost do-while loop
                }
                if (...) {
                    continue; // skips current iteration in the while loop
                }
            }
        }
        if (...) {
            break loop;
        }
        if (...) {
            break loop;
        }
        if (...) {
            break loop;
        }
        if (...) {
            break loop;
        }
        ok = true;
        break;
    } while(true);
    CleanupAndCallbackBeforeReturning(ok);
    return ok;
};

найкращий спосіб -
1) Сортувати обидва масиви, які використовуються у першому та другому циклі.
2) якщо елемент збігається, тоді перервіть внутрішній цикл і утримуйте значення індексу.
3) при наступній ітерації запустіть внутрішній цикл зі значенням індексу утримування.