如何打破循环？
var largest=0
for(i<-999 to 1 by -1) {
for (j<-i to 1 by -1) {
val product=i*j
if (largest>product)
// I want to break out here
else
if(product.toString.equals(product.toString.reverse))
largest=largest max product
}
}
如何将嵌套的 for 循环转换为尾递归？
来自 FOSDEM 2009 上的 Scala Talk http://www.slideshare.net/Odersky/fosdem-2009-1013261 第 22 页：
Break and continue Scala 没有它们。为什么？它们有点势在必行。更好地使用许多较小的函数 问题如何与闭包交互。他们不需要！
解释是什么？
您有三个（左右）选项可以跳出循环。
假设您想对数字求和，直到总数大于 1000。您尝试
var sum = 0
for (i <- 0 to 1000) sum += i
除非您想在（总和 > 1000）时停止。
该怎么办？有几种选择。
(1a) 使用一些包含您测试的条件的构造。
var sum = 0
(0 to 1000).iterator.takeWhile(_ => sum < 1000).foreach(i => sum+=i)
（警告——这取决于 takeWhile 测试和 foreach 在评估期间如何交错的细节，可能不应该在实践中使用！）。
(1b) 使用尾递归而不是 for 循环，利用在 Scala 中编写新方法的容易程度：
var sum = 0
def addTo(i: Int, max: Int) {
sum += i; if (sum < max) addTo(i+1,max)
}
addTo(0,1000)
(1c) 回退到使用 while 循环
var sum = 0
var i = 0
while (i <= 1000 && sum <= 1000) { sum += 1; i += 1 }
(2) 抛出异常。
object AllDone extends Exception { }
var sum = 0
try {
for (i <- 0 to 1000) { sum += i; if (sum>=1000) throw AllDone }
} catch {
case AllDone =>
}
(2a) 在 Scala 2.8+ 中，这已经使用语法预先打包scala.util.control.Breaks，看起来很像您熟悉的 C/Java 旧中断：
import scala.util.control.Breaks._
var sum = 0
breakable { for (i <- 0 to 1000) {
sum += i
if (sum >= 1000) break
} }
(3) 将代码放入方法中，使用return。
var sum = 0
def findSum { for (i <- 0 to 1000) { sum += i; if (sum>=1000) return } }
findSum
出于我能想到的至少三个原因，故意使这不太容易。首先，在大型代码块中，很容易忽略“继续”和“中断”语句，或者认为您的中断比实际情况多或少，或者需要中断两个无法执行的循环无论如何都很容易 - 所以标准用法虽然方便，但有问题，因此您应该尝试以不同的方式构建代码。其次，Scala 有各种你可能根本没有注意到的嵌套，所以如果你能打破这些东西，你可能会对代码流的最终位置感到惊讶（尤其是闭包）。第三，Scala 的大多数“循环”实际上并不是普通的循环——它们是有自己循环的方法调用，looplike，很难想出一个一致的方法来知道“break”之类的应该做什么。因此，为了保持一致，更明智的做法是根本不“休息”。
注意：所有这些都有功能等价物，您可以在其中返回值sum而不是对其进行变异。这些是更惯用的Scala。但是，逻辑保持不变。（return变成return x等）。
这在 Scala 2.8 中发生了变化，它具有使用中断的机制。您现在可以执行以下操作：
import scala.util.control.Breaks._
var largest = 0
// pass a function to the breakable method
breakable {
for (i<-999 to 1 by -1; j <- i to 1 by -1) {
val product = i * j
if (largest > product) {
break // BREAK!!
}
else if (product.toString.equals(product.toString.reverse)) {
largest = largest max product
}
}
}
跳出 for 循环绝不是一个好主意。如果您使用的是 for 循环，则意味着您知道要迭代多少次。使用具有 2 个条件的 while 循环。
例如
var done = false
while (i <= length && !done) {
if (sum > 1000) {
done = true
}
}
以另一种方式添加 Rex Kerr 答案：
(1c) 你也可以在你的循环中使用一个守卫：
var sum = 0
for (i <- 0 to 1000 ; if sum<1000) sum += i
由于breakScala 中还没有，您可以尝试使用return-statement 来解决这个问题。因此，您需要将内部循环放入函数中，否则返回将跳过整个循环。
然而，Scala 2.8 包含了一种打破
http://www.scala-lang.org/api/rc/scala/util/control/Breaks.html
一种在我们迭代时生成一个范围内的值的方法，直到一个中断条件，而不是首先生成一个整个范围然后迭代它，使用Iterator, （灵感来自 @RexKerr 的使用Stream）
var sum = 0
for ( i <- Iterator.from(1).takeWhile( _ => sum < 1000) ) sum += i
简单地说，我们可以在 scala 中做的是
scala> import util.control.Breaks._
scala> object TestBreak {
def main(args : Array[String]) {
breakable {
for (i <- 1 to 10) {
println(i)
if (i == 5)
break;
} } } }
输出 ：
scala> TestBreak.main(Array())
1
2
3
4
5
// import following package
import scala.util.control._
// create a Breaks object as follows
val loop = new Breaks;
// Keep the loop inside breakable as follows
loop.breakable{
// Loop will go here
for(...){
....
// Break will go here
loop.break;
}
}
使用中断模块 http://www.tutorialspoint.com/scala/scala_break_statement.htm
只需使用一个while循环：
var (i, sum) = (0, 0)
while (sum < 1000) {
sum += i
i += 1
}
这是一个尾递归版本。诚然，与理解相比，它有点神秘，但我想说它的功能:)
def run(start:Int) = {
@tailrec
def tr(i:Int, largest:Int):Int = tr1(i, i, largest) match {
case x if i > 1 => tr(i-1, x)
case _ => largest
}
@tailrec
def tr1(i:Int,j:Int, largest:Int):Int = i*j match {
case x if x < largest || j < 2 => largest
case x if x.toString.equals(x.toString.reverse) => tr1(i, j-1, x)
case _ => tr1(i, j-1, largest)
}
tr(start, 0)
}
如您所见，tr 函数是外部 for-comprehensions 的对应物，而 tr1 是内部 for-comprehensions 的对应物。如果您知道优化我的版本的方法，欢迎您。
接近你的解决方案是这样的：
var largest = 0
for (i <- 999 to 1 by -1;
j <- i to 1 by -1;
product = i * j;
if (largest <= product && product.toString.reverse.equals (product.toString.reverse.reverse)))
largest = product
println (largest)
j 迭代是在没有新范围的情况下进行的，产品生成和条件是在 for 语句中完成的（不是一个好的表达式 - 我找不到更好的表达式）。条件是相反的，这对于该问题的大小来说是相当快的——也许你会在更大的循环中获得一些突破。
String.reverse 隐式转换为 RichString，这就是我进行 2 次额外反转的原因。:) 更数学的方法可能更优雅。
我是 Scala 新手，但是如何避免抛出异常和重复方法：
object awhile {
def apply(condition: () => Boolean, action: () => breakwhen): Unit = {
while (condition()) {
action() match {
case breakwhen(true) => return ;
case _ => { };
}
}
}
case class breakwhen(break:Boolean);
像这样使用它：
var i = 0
awhile(() => i < 20, () => {
i = i + 1
breakwhen(i == 5)
});
println(i)
如果你不想打破：
awhile(() => i < 20, () => {
i = i + 1
breakwhen(false)
});
import scala.util.control._
object demo_brk_963
{
def main(args: Array[String])
{
var a = 0;
var b = 0;
val numList1 = List(1,2,3,4,5,6,7,8,9,10);
val numList2 = List(11,12,13);
val outer = new Breaks; //object for break
val inner = new Breaks; //object for break
outer.breakable // Outer Block
{
for( a <- numList1)
{
println( "Value of a: " + a);
inner.breakable // Inner Block
{
for( b <- numList2)
{
println( "Value of b: " + b);
if( b == 12 )
{
println( "break-INNER;");
inner.break;
}
}
} // inner breakable
if( a == 6 )
{
println( "break-OUTER;");
outer.break;
}
}
} // outer breakable.
}
}
使用 Breaks 类中断循环的基本方法。通过将循环声明为可破坏的。
第三方breakable包是一种可能的选择
https://github.com/erikerlandson/breakable
示例代码：
scala> import com.manyangled.breakable._
import com.manyangled.breakable._
scala> val bkb2 = for {
| (x, xLab) <- Stream.from(0).breakable // create breakable sequence with a method
| (y, yLab) <- breakable(Stream.from(0)) // create with a function
| if (x % 2 == 1) continue(xLab) // continue to next in outer "x" loop
| if (y % 2 == 0) continue(yLab) // continue to next in inner "y" loop
| if (x > 10) break(xLab) // break the outer "x" loop
| if (y > x) break(yLab) // break the inner "y" loop
| } yield (x, y)
bkb2: com.manyangled.breakable.Breakable[(Int, Int)] = com.manyangled.breakable.Breakable@34dc53d2
scala> bkb2.toVector
res0: Vector[(Int, Int)] = Vector((2,1), (4,1), (4,3), (6,1), (6,3), (6,5), (8,1), (8,3), (8,5), (8,7), (10,1), (10,3), (10,5), (10,7), (10,9))
具有讽刺意味的是，Scala 闯入scala.util.control.Breaks是一个例外：
def break(): Nothing = { throw breakException }
最好的建议是：不要使用 break、continue 和 goto！IMO 他们是相同的，不好的做法和各种问题（和热门讨论）的邪恶来源，最终“被认为是有害的”。代码块结构化，在这个例子中中断也是多余的。我们的 Edsger W. Dijkstra† 写道：
程序员的素质是他们编写的程序中 go to 语句密度的递减函数。
我不知道过去 9 年 Scala 风格发生了多大变化，但我发现有趣的是，大多数现有答案都使用vars，或者难以阅读递归。提前退出的关键是使用惰性集合来生成可能的候选者，然后单独检查条件。要生成产品：
val products = for {
i <- (999 to 1 by -1).view
j <- (i to 1 by -1).view
} yield (i*j)
然后从该视图中找到第一个回文而不生成每个组合：
val palindromes = products filter {p => p.toString == p.toString.reverse}
palindromes.head
要找到最大的回文数（虽然懒惰并没有给你带来太多好处，因为无论如何你都必须检查整个列表）：
palindromes.max
您的原始代码实际上是检查大于后续产品的第一个回文，这与检查第一个回文相同，除了我认为您不打算的奇怪边界条件。产品不是严格单调递减的。例如，998*998大于999*997，但在循环中出现得更晚。
无论如何，分离的惰性生成和条件检查的优点是您编写它就像使用整个列表一样，但它只生成您需要的数量。你有点两全其美。
我遇到了类似下面代码的情况
for(id<-0 to 99) {
try {
var symbol = ctx.read("$.stocks[" + id + "].symbol").toString
var name = ctx.read("$.stocks[" + id + "].name").toString
stocklist(symbol) = name
}catch {
case ex: com.jayway.jsonpath.PathNotFoundException=>{break}
}
}
我正在使用 java lib，机制是 ctx.read 在找不到任何东西时抛出异常。我被困在这样的情况下：当抛出异常时我必须打破循环，但是 scala.util.control.Breaks.break 使用 Exception 来打破循环，并且它在 catch 块中，因此它被捕获了。
我有一个丑陋的方法来解决这个问题：第一次循环并获得实际长度的计数。并将其用于第二个循环。
当您使用一些 java 库时，从 Scala 中脱颖而出并不是那么好。
下面是以简单的方式打破循环的代码
import scala.util.control.Breaks.break
object RecurringCharacter {
def main(args: Array[String]) {
val str = "nileshshinde";
for (i <- 0 to str.length() - 1) {
for (j <- i + 1 to str.length() - 1) {
if (str(i) == str(j)) {
println("First Repeted Character " + str(i))
break() //break method will exit the loop with an Exception "Exception in thread "main" scala.util.control.BreakControl"
}
}
}
}
}
巧妙地使用find收集方法将为您解决问题。
var largest = 0
lazy val ij =
for (i <- 999 to 1 by -1; j <- i to 1 by -1) yield (i, j)
val largest_ij = ij.find { case(i,j) =>
val product = i * j
if (product.toString == product.toString.reverse)
largest = largest max product
largest > product
}
println(largest_ij.get)
println(largest)