什么'；在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.
         }
      }
   }
}

//将链接写入页面。
对于（变量x=0；x中断；//将其包装到函数中，然后像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
            }
        }
    }

如EMCA-262第12.12节所定义

与C不同，这些标签只能用于和，因为Javascript没有
goto
var str=”“；
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
}

对于（变量x=0；x<3；x++）{
（function（）{//这里有一个匿名函数
对于（变量y=0；y<3；y++）{
对于（var z=0；z<3；z++）{
//由于闭包，您可以访问“x”
str+=“x=“+x+”y=“+y+”z=“+z+”
”；
如果（x==z&&z==2）{
返回；
}
}
}
})（）；//在这里，执行匿名函数
}

怎么样？：）
我来晚了一点，但以下是一种语言不可知的方法，它不使用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
      }
   }
}

从正面看，它自然地流动，这应该会让非GOTO人群满意。从反面看，内部循环需要在终止之前完成当前迭代，因此在某些情况下可能不适用。
非常简单：

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

我意识到这是一个非常古老的话题，但由于我的标准方法还没有出现，我想我会把它发布给未来的谷歌

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 a、b、abort=false；
对于（a=0；a<10&&！中止；a++）{
对于（b=0；b<10&&！中止；b++）{
如果（条件）{
doSomeThing（）；
中止=真；
}
}
}
完全不使用中断、不使用中止标志，也不使用额外的条件检查如何。此版本仅在满足条件时爆炸循环变量（使其成为
Number.MAX\u 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
    }
  }
}

//不需要中断
对于（变量i=0；i<10；i++）{
对于（var j=0；j<10；j++）{
如果（条件）{
控制台日志（“满足条件”）；
i=j=Number.MAX_VALUE；//清除循环变量
}
}
}

对于递减型嵌套循环，存在类似的ISH答案，但这适用于递增型嵌套循环，而不需要考虑每个循环对于简单循环的终止值。
另一个例子：

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

//不需要中断
对于（变量i=0；i<89；i++）{
对于（var j=0；j<1002；j++）{
对于（var k=0；k<16；k++）{
对于（var l=0；l<2382；l++）{
如果（条件）{
控制台日志（“满足条件”）；
i=j=k=l=Number.MAX_VALUE；//清除循环变量
}
}
}
}
}
如果您使用Coffeescript，则有一个方便的“do”关键字，可以更轻松地定义并立即执行匿名函数：

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

…因此您可以简单地使用“return”来摆脱循环。
我想我应该展示一种函数式编程方法。您可以打破嵌套的Array.prototype.some（）和/或Array.prototype.every（）函数，就像在我的解决方案中一样。这种方法的另一个好处是
Object.keys（）
仅枚举对象自身的可枚举属性，而

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

Args.forEach（函数（arg）{
//这个守卫是没有必要的，
//因为将空字符串写入文档不会改变它。
如果（！getAnchorTag（arg））
返回；
文件写入（getAnchorTag（arg））；
});
函数getAnchorTag（名称）{
var-res=''；
对象。键（导航。标题）。一些（函数（标题）{
返回Object.key（导航.标题[标题]）.some（函数（项）{
if（name==Navigation.Headings[Heading][Item].name）{
res=（“：”）；
返回true；
}
});
});
返回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;
            }
        });
    });

var remainingArgs=Args.slice（0）；
对象。键（导航。标题）。一些（函数（标题）{
返回Object.key（导航.标题[标题]）.some（函数（项）{
var i=remainargs.indexOf（导航.标题[标题][项目].Name）；
如果（i==-1）
返回；
文件。写（“：”）；
剩余RGS拼接（i，1）；
if（remainargs.length==0）
返回true；
}
});
});
最好的方法是-

1） 对第一个循环和第二个循环中使用的两个数组进行排序。

2） 如果项目匹配，则中断内部循环并保留索引值。

3） 当开始下一次迭代时，使用保持索引值启动内部循环。
将循环推到其结束极限如何

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

for（var a=0；a之前已经被swilliams提到过，但下面有一个例子（Javascript）：

//函数为循环包装内部
功能标准匹配（记录、标准）{
for（标准中的var k）{
如果（！（记录中的k））
返回false；
如果（记录[k]！=标准[k]）
返回false；
}
返回true；
}
//如果内部for循环返回false，则外部for循环实现continue
var结果=[]；
对于（变量i=0；i<_table.length；i++）{
var r=_表[i]；
如果（！准则匹配（r[i]，准则））
继续；
结果：添加（r）；
}
以下是在JavaScript中打破嵌套循环的五种方法：

1）将父循环设置到末尾

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

（i=0；i<5；i++）的

{
对于（j=0；j<5；j++）
{
如果（j==2）
{
i=5；
打破
}
}
}

2）使用标签

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

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

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

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

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

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

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

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

try{  
    for (var i in set1) {
        for (var j in set2) {
            for (var k in set3) {
                throw error;
            }
        }
    }
}catch (error) {

}