Quelle est la meilleure façon de rompre avec les boucles imbriquées en JavaScript?

Quelle est la meilleure façon de rompre avec les boucles imbriquées en 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.
         }
      }
   }
}

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

comme défini dans EMCA-262 section 12.12. [MDN Docs]

Contrairement à C, ces étiquettes ne peuvent être utilisées que pour continueet break, comme Javascript ne l'est pas goto.

Enveloppez cela dans une fonction, puis juste return.

Je suis un peu en retard à la fête, mais ce qui suit est une approche indépendante du langage qui n'utilise pas GOTO / labels ou wrapping de fonction:

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

À la hausse, il coule naturellement, ce qui devrait plaire à la foule non-GOTO. Sur le plan négatif, la boucle interne doit terminer l'itération actuelle avant de se terminer, de sorte qu'elle pourrait ne pas être applicable dans certains scénarios.

Je me rends compte que c'est un sujet vraiment ancien, mais comme mon approche standard n'est pas encore là, j'ai pensé le poster pour les futurs googleurs.

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
}

Comment ça? :)

Assez facile:

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

Voici cinq façons de sortir des boucles imbriquées en JavaScript:

1) Définissez la boucle parent (s) à la fin

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

2) Utilisez une étiquette

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

3) Utiliser une variable

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) Utiliser la fonction auto-exécutable

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

5) Utilisez la fonction régulière

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

Que diriez-vous de n'utiliser aucune interruption, aucun indicateur d'abandon et aucun contrôle de condition supplémentaire. Cette version blastes juste les variables de boucle (les fait Number.MAX_VALUE) lorsque la condition est remplie et force toutes les boucles à se terminer avec élégance.

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

Il y avait une réponse similaire pour les boucles imbriquées de type décrémentation, mais cela fonctionne pour les boucles imbriquées de type incrémentation sans avoir à prendre en compte la valeur de terminaison de chaque boucle pour les boucles simples.

Un autre exemple:

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

Que diriez-vous de pousser les boucles à leurs limites

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

Si vous utilisez Coffeescript, il existe un mot clé "do" pratique qui facilite la définition et l'exécution immédiate d'une fonction anonyme:

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

... vous pouvez donc simplement utiliser "retour" pour sortir des boucles.

Je pensais que je montrerais une approche de programmation fonctionnelle. Vous pouvez sortir des fonctions imbriquées Array.prototype.some () et / ou Array.prototype.every (), comme dans mes solutions. Un avantage supplémentaire de cette approche est qu'elle Object.keys()énumère uniquement les propriétés énumérables d'un objet, tandis que "une boucle for-in énumère également les propriétés de la chaîne de prototypes" .

Proche de la solution 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;
    }

Solution qui réduit l'itération sur les en-têtes / articles:

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

Déjà mentionné précédemment par swilliams , mais avec un exemple ci-dessous (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 salut à la fête des 10 ans?

Pourquoi ne pas mettre une condition dans votre?

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

Comme ça tu t'arrêtes quand tu veux

Dans mon cas, en utilisant Typescript, nous pouvons utiliser certains () qui passent par le tableau et s'arrêtent lorsque la condition est remplie Donc mon code devient comme ceci:

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

Comme ça, la boucle s'est arrêtée juste après que la condition soit remplie

Rappel: ce code s'exécute en 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;
};

la meilleure façon est -
1) Trier les deux tableaux qui sont utilisés dans la première et la deuxième boucle.
2) si l'élément correspond, rompez la boucle intérieure et maintenez la valeur d'index.
3) au début de l'itération suivante, lancer la boucle interne avec une valeur d'index de maintien.