代码之家  ›  专栏  ›  技术社区  ›  ses

Scala返回不返回

  •  1
  • ses  · 技术社区  · 13 年前

    我和Scala之间有一些误解

    0还是1?

    object Fun extends App {
    
     def foo(list:List[Int], count:Int = 0): Int = {
    
        if (list.isEmpty) { // when this is true
          return 1   // and we are about to return 1, the code goes to the next line
        }
    
        foo(list.tail, count + 1) // I know I do not use "return here" ...
    
        count
      }
    
      val result = foo( List(1,2,3) )
    
      println ( result ) // 0
    
    }
    
    1. 为什么要打印0?
    2. 为什么递归即使没有“返回”也能工作 (当它处于函数的中间,但不是最后)?
    3. 为什么不返回1?当我明确使用“return”时?

    ---编辑:

    如果我使用它,它会起作用 return 在这里 "return foo(list.tail, count + 1)' . 但这并不能解释(对我来说)为什么“返回1”在上面不起作用。

    5 回复  |  直到 13 年前
        1
  •  8
  •   DaoWen    13 年前

    如果你阅读了我下面的完整解释,那么你的三个问题的答案应该都很清楚,但为了方便大家,这里有一个简短、明确的摘要:

    1. 为什么要打印0? 这是因为方法调用正在返回 count ,默认值为 0 所以它回来了 0 然后打印 0 。如果你用 count=5 然后它就会打印出来 5 相反(参见使用的示例 println 以下。)
    2. 为什么递归即使没有“return”也能工作(当它位于函数的中间,但不是最后)? 您正在进行递归调用,因此递归会发生,但您没有返回递归调用的结果。
    3. 为什么不返回1?当我明确使用“return”时? 确实如此,但仅在以下情况下 list 是空的。如果 列表 不为空,则返回 计数 相反(同样,请参见使用 打印 以下。)

    这是引用自 在Scala中编程 作者:Odersky(第一版可在线获取):

    事实上,推荐的方法样式是避免使用显式返回语句,尤其是多个返回语句。相反,将每个方法视为一个生成一个值的表达式,并返回该值。这种哲学会鼓励你把方法做得很小,把较大的方法分解成多个较小的方法。另一方面,设计选择取决于设计上下文,Scala使编写具有多个显式返回的方法变得容易,如果这是您想要的。 [link]

    在Scala中,您很少使用 return 关键字,但要利用 表示 将返回值传播回方法的顶级表达式,然后将该结果用作返回值。你可以考虑 回来 更像 break 或 goto ,这会中断正常的控制流,并可能使您的代码更难推理。

    Scala没有像Java那样的语句,但一切都是 表示 ,意味着一切都会返回一个值。这也是Scala拥有 Unit 而不是 void 因为即使是 无效的 在Java中需要在Scala中返回一个值。以下是一些与代码相关的表达式如何工作的示例:

    1. Java中的表达式在Scala中的作用是一样的。这意味着 1+1 是 2 ,以及的结果 x.y() 是方法调用的返回值。
    2. Java有if 声明 ,但Scala有if 表达 这意味着Scala if / else 构造的行为更像 Java ternary operator 因此 if (x) y else z 相当于 x ? y : z 在Java中。一个孤独的人 如果 就像你用过的一样 if (x) y else Unit .
    3. Java中的代码块是由一组语句组成的语句,但在Scala中,它是由一群表达式组成的表达式。代码块的结果是该块中最后一个表达式的结果。因此,{o.a();o.b();o.c()}的结果是任意的 o.c() 返回。您可以使用制作类似的构造 the comma operator in C/C++ : (o.a(), o.b(), o.c()) Java实际上并没有这样的东西。
    4. 这个 回来 关键字破坏了表达式中的正常控制流,导致当前方法立即返回给定的值。你可以把它看作是抛出一个异常,这既是因为它是正常控制流的异常,也是因为(比如 throw 关键字)生成的表达式具有类型 Nothing 这个 没有什么 类型用于指示从不返回值的表达式,因此在类型推理过程中基本上可以忽略它。下面是一个简单的例子 回来 结果类型为 没有什么 :
    def f(x: Int): Int = {
      val nothing: Nothing = { return x }
      throw new RuntimeException("Can't reach here.")
    }
    

    基于所有这些,我们可以看看你的方法,看看发生了什么:

     def foo(list:List[Int], count:Int = 0): Int = { 
       // This block (started by the curly brace on the previous line
       // is the top-level expression of this method, therefore its result
       // will be used as the result/return value of this method.
         if (list.isEmpty) {
           return 1 // explicit return (yuck)
         }
         foo(list.tail, count + 1) // recursive call
         count // last statement in block is the result
      }
    

    现在你应该可以看到了 计数 正在作为方法的结果使用,除非您使用 回来 。你可以看到 回来 正在工作,因为 foo(List(), 5) 退货 1 相反 foo(List(0), 5) 退货 5. 因为它使用的是块的结果, 计数 ,作为返回值。如果你尝试一下,你可以清楚地看到这一点:

    println(foo(List()))      // prints 1 because list is empty
    println(foo(List(), 5))   // prints 1 because list is empty
    println(foo(List(0)))     // prints 0 because count is 0 (default)
    println(foo(List(0), 5))  // prints 5 because count is 5
    

    您应该重新构造方法,使主体的值是一个表达式,而返回值只是该表达式的结果。看起来您正试图编写一个方法来返回列表中的项数。如果是这样的话,我会这样改变:

     def foo(list:List[Int], count:Int = 0): Int = {
       if (list.isEmpty) count
       else foo(list.tail, count + 1)
     }
    

    当以这种方式编写时,在基本情况下(列表为空),它返回当前项计数,否则它返回列表尾部递归调用的结果 count+1 .

    如果你 真正地 希望它总是回来 1. 你可以把它改成 if (list.isEmpty) 1 相反,它将始终返回 1. 因为基本情况总是会返回 1. .

        2
  •  1
  •   Hiura Devank    13 年前

    您正在返回的值 count 从第一次呼叫(即, 0 ),而不是来自foo递归调用的值。

    更确切地说,在您的代码中,您不使用对foo的递归调用的返回值。

    以下是修复方法:

    def foo(list:List[Int], count:Int = 0): Int = {
    
        if (list.isEmpty) {
            1
        } else {
            foo(list.tail, count + 1)
        }
    }
    

    这样,你就可以 1 .

    顺便说一句,不要使用 return 。它并不总是像你期望的那样。

    在Scala中,函数隐式返回最后一个值。你不需要明确地写 回来 .

        3
  •  1
  •   Alex Yarmula    13 年前

    你的 return 有效,只是不是你期望的方式,因为你忽略了它的价值。如果你传递一个空列表,你会得到1,正如你所期望的那样。 因为您传递的不是一个空列表,所以您的原始代码是这样工作的:

    • foo 使用3个元素的列表和计数0调用(调用此递归1)
    • 列表不是空的,所以我们不会进入带有 回来
    • 我们递归地输入 足球 ,现在有2个元素,计数为1(递归级别2)
    • 列表不是空的,所以我们不会进入带有 回来
    • 我们递归地输入 足球 ,现在有1个元素和计数2(递归级别3)
    • 列表不是空的,所以我们不会进入带有 回来
    • 我们现在进入 足球 没有元素,计数为3(递归级别4)
    • 我们进入街区 回来 和返回1
    • 我们回到递归级别3。调用的结果 足球 我们刚刚回来,既没有分配也没有返回,所以它被忽略了。我们继续下一行并返回count,它与传入的值相同,2
    • 同样的事情也发生在递归级别2和1上——我们忽略 足球 并返回原件 count
    • 的价值 计数 在递归级别上,1为0,这是最终结果
        4
  •  1
  •   DryingPole    13 年前

    事实上,您在foo前面没有返回(list.tail,count+1),这意味着,在您从递归返回后,执行将失败并返回count。由于0是作为count的默认值传递的,所以一旦您从所有递归调用中返回,您的函数就会返回count的原始值。

    如果将以下println添加到代码中,您可以看到这种情况的发生:

    def foo(list:List[Int], count:Int = 0): Int = {
    
         if (list.isEmpty) { // when this is true
            return 1   // and we are about to return 1, the code goes to the next line
         }
    
        foo(list.tail, count + 1) // I know I do not use "return here" ...
    
         println ("returned from foo " + count)
         count
    }
    

    要解决这个问题,您应该在foo前面添加一个return(list.tail…..)。

        5
  •  0
  •   Arne    13 年前

    您在程序中返回count,它是一个常量,初始化为0,所以这就是您在递归的顶层返回的内容。

    推荐文章