Jaki jest najlepszy sposób na zerwanie z zagnieżdżonych pętli w JavaScript?

Jaki jest najlepszy sposób na oderwanie się od zagnieżdżonych pętli w 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.
         }
      }
   }
}

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

zgodnie z definicją w EMCA-262 sekcja 12.12. [Dokumenty MDN]

W przeciwieństwie do C, te etykiety mogą być używane tylko dla continuei break, ponieważ JavaScript nie ma goto.

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

Jestem trochę spóźniony na imprezę, ale poniższe podejście jest niezależne od języka, które nie używa GOTO / etykiet ani pakowania 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
      }
   }
}

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

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

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
}

Jak to? :)

Całkiem 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;
}

Oto pięć sposobów na wyrwanie się z zagnieżdżonych pętli w JavaScript:

1) Ustaw pętlę rodzica (rodziców) na końcu

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

2) Użyj etykiety

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

3) Użyj zmiennej

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) Użyj funkcji samodzielnego wykonywania

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

5) Użyj zwykłej funkcji

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

Co powiesz na to, by nie używać żadnych przerw, żadnych flag przerwania i żadnych dodatkowych kontroli warunków. Ta wersja po prostu wysadza zmienne w pętli (czyni je Number.MAX_VALUE), gdy warunek jest spełniony, i zmusza wszystkie pętle do eleganckiego zakończenia.

// 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ź na zagnieżdżone pętle typu zmniejszającego, ale działa to na zagnieżdżone pętle typu bez konieczności rozważania wartości końcowej 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
        }
      }
    }
  }
}

Co powiesz na przesunię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 anonimowej funkcji:

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

... dzięki czemu możesz po prostu użyć „return”, aby wyjść z pętli.

Myślałem, że pokażę podejście programowania funkcjonalnego. Możesz wyrwać się z zagnieżdżonych funkcji Array.prototype.some () i / lub Array.prototype.every (), jak w moich rozwiązaniach. Dodatkową zaletą tego podejścia jest to, że Object.keys()wylicza tylko własne wyliczalne 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, które zmniejsza iterację nagłówków / pozycji:

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

Wspomniane już wcześniej przez swilliams , ale z poniższym przykładem (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);
}

Hmmm cześć na 10-letniej imprezie?

Dlaczego nie postawić jakiegoś warunku?

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

W ten sposób zatrzymujesz się, kiedy chcesz

W moim przypadku, używając Typescript, możemy użyć niektórych (), które przechodzą przez tablicę i zatrzymują się, gdy warunek jest spełniony, więc mój kod wygląda następująco:

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

W ten sposób pętla zatrzymała się zaraz po spełnieniu warunku

Przypomnienie: ten kod działa w 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;
};

najlepszym sposobem jest -
1) Posortuj obie tablice, które są używane w pierwszej i drugiej pętli.
2) jeśli element pasuje, przerwij wewnętrzną pętlę i przytrzymaj wartość indeksu.
3) przy rozpoczęciu następnej iteracji rozpocznij wewnętrzną pętlę z wartością indeksu wstrzymania.