Was ist der beste Weg, um verschachtelte Schleifen in JavaScript zu lösen?

Was ist der beste Weg, um verschachtelte Schleifen in Javascript zu lösen?

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

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

wie in Abschnitt 12.12 von EMCA-262 definiert. [MDN-Dokumente]

Im Gegensatz zu C können diese Bezeichnungen nur für continueund verwendet werden break, da Javascript dies nicht hat goto.

Wickeln Sie das in eine Funktion ein und dann einfach return.

Ich bin etwas spät zur Party, aber das Folgende ist ein sprachunabhängiger Ansatz, bei dem GOTO / Labels oder Funktionsumbruch nicht verwendet werden:

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

Auf der Oberseite fließt es natürlich, was der Nicht-GOTO-Menge gefallen sollte. Auf der anderen Seite muss die innere Schleife die aktuelle Iteration vor dem Beenden abschließen, damit sie in einigen Szenarien möglicherweise nicht anwendbar ist.

Mir ist klar, dass dies ein wirklich altes Thema ist, aber da mein Standardansatz noch nicht hier ist, dachte ich, ich poste ihn für die zukünftigen Googler.

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
}

Wie ist das? :) :)

Ziemlich einfach:

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

Hier sind fünf Möglichkeiten, um aus verschachtelten Schleifen in JavaScript auszubrechen:

1) Setzen Sie die übergeordnete (n) Schleife (n) auf das Ende

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

2) Etikett verwenden

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

3) Variable verwenden

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) Verwenden Sie die selbstausführende Funktion

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

5) Verwenden Sie die reguläre Funktion

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

Wie wäre es, wenn Sie überhaupt keine Unterbrechungen, keine Abbruchflags und keine zusätzlichen Bedingungsprüfungen verwenden? Diese Version sprengt nur die Schleifenvariablen (macht sie Number.MAX_VALUE), wenn die Bedingung erfüllt ist, und zwingt alle Schleifen, elegant zu enden.

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

Es gab eine ähnliche Antwort für verschachtelte Schleifen vom Dekrementiertyp, dies funktioniert jedoch für inkrementelle verschachtelte Schleifen, ohne den Abschlusswert jeder Schleife für einfache Schleifen berücksichtigen zu müssen.

Ein anderes Beispiel:

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

Wie wäre es, Schleifen an ihre Endgrenzen zu bringen?

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

Wenn Sie Coffeescript verwenden, gibt es ein praktisches Schlüsselwort "do", mit dem Sie eine anonyme Funktion einfacher definieren und sofort ausführen können:

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

... also können Sie einfach "return" verwenden, um aus den Schleifen herauszukommen.

Ich dachte, ich würde einen funktionalen Programmieransatz zeigen. Sie können wie in meinen Lösungen aus verschachtelten Funktionen von Array.prototype.some () und / oder Array.prototype.every () ausbrechen. Ein zusätzlicher Vorteil dieses Ansatzes besteht darin, dass Object.keys()nur die eigenen aufzählbaren Eigenschaften eines Objekts aufgelistet werden, während "eine For-In-Schleife auch Eigenschaften in der Prototypkette auflistet" .

Nah an der Lösung des 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;
    }

Lösung, die das Durchlaufen der Überschriften / Elemente reduziert:

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

Bereits zuvor von Swilliams erwähnt , aber mit einem Beispiel unten (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 hallo zur 10 Jahre alten Party?

Warum nicht eine Bedingung in Ihr für setzen?

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

So hörst du auf, wenn du willst

In meinem Fall können wir mit Typescript einige () verwenden, die das Array durchlaufen und anhalten, wenn die Bedingung erfüllt ist. Mein Code sieht also folgendermaßen aus:

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

Auf diese Weise wurde die Schleife direkt nach Erfüllung der Bedingung gestoppt

Erinnerung: Dieser Code wird in TypeScript ausgeführt

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

Der beste Weg ist -
1) Sortieren Sie die beiden Arrays, die in der ersten und zweiten Schleife verwendet werden.
2) Wenn das Element übereinstimmt, unterbrechen Sie die innere Schleife und halten Sie den Indexwert.
3) Wenn Sie die nächste Iteration starten, starten Sie die innere Schleife mit dem Hold-Index-Wert.