Najlepszy sposób na oderwanie się od zagnieżdżonych pętli w Javascript?

Zawiń to w funkcję, a następnie po prostu return.

Jestem trochę spóźniony na imprezę, ale poniżej znajduje się podejście agnostyczne, które nie używa GOTO/etykiet ani owijania funkcji:

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

Na plusie płynie naturalnie, co powinno zadowolić tłum nie-GOTO. Z drugiej strony, pętla wewnętrzna musi zakończyć bieżącą iterację przed zakończeniem, więc może nie być stosowana w niektórych scenariuszach.

Zdaję sobie sprawę, że to naprawdę stary temat, ale ponieważ moje standardowe podejście nie jest jeszcze tutaj, pomyślałem, że opublikuję go dla przyszłych googlerów.

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
}

Dość proste

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

Jak o użyciu żadnych przerw w ogóle, żadnych flag przerwania, i żadnych dodatkowych kontroli stanu. Ta wersja po prostu usuwa zmienne pętli (czyni je Number.MAX_VALUE), gdy warunek jest spełniony i wymusza eleganckie zakończenie wszystkich pętli.

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

Była podobna odpowiedź dla pętli zagnieżdżonych, ale działa to dla pętli zagnieżdżonych bez konieczności rozważania wartości zakończenia każdej pętli dla prostych pętli.

Inny przykład:

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

A może przepchnięcie pętli do ich granic końcowych

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

Jeśli używasz Coffeescript, istnieje wygodne słowo kluczowe "do", które ułatwia zdefiniowanie i natychmiastowe wykonanie funkcji anonimowej:

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

... więc możesz po prostu użyć "return", aby wydostać się z pętli.

Pomyślałem, że pokażę podejście do programowania funkcjonalnego. Możesz wyłamać się z zagnieżdżonej tablicy.prototyp.some() i / lub Array.prototyp.every () functions, as in my solutions. Dodatkową zaletą tego podejścia jest to, że Object.keys() wylicza tylko własne właściwości obiektu, podczas gdy "pętla for-in wylicza również właściwości w łańcuchu prototypów" .

Blisko rozwiązania OP:

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

Rozwiązanie redukujące iterację nad nagłówkami/przedmiotami:

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

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

The best way is -
1) posortuj obie tablice, które są używane w pierwszej i drugiej pętli.
2) Jeśli element jest dopasowany, przerwij wewnętrzną pętlę i przytrzymaj wartość indeksu.
3) Po uruchomieniu następnej iteracji Uruchom wewnętrzną pętlę z wartością indeksu hold.

Wiem, że pytano o to 8 lat temu, ale w ES6 dostaliśmy za...pętli , która umożliwia korzystanie z funkcji Standard break :

for (let item of items) {
  if (item.id === id) {
    //do something cool
    break;
  }
}