在Scala中定义方法的九种方法？_Scala_Methods_Function

在Scala中定义方法的九种方法？

scala methods function

在Scala中定义方法的九种方法？,scala,methods,function,Scala,Methods,Function,因此，我一直在尝试各种在Scala中定义东西的方法，由于我对{}块的处理方式缺乏了解，这使我变得更加复杂： object NewMain extends Thing{ def f1 = 10 def f2 {10} def f3 = {10} def f4() = 10 def f5() {10} def f6() = {10} def f7 = () => 10 def f8 = () => {10} def

因此，我一直在尝试各种在Scala中定义东西的方法，由于我对

{}

块的处理方式缺乏了解，这使我变得更加复杂：

object NewMain extends Thing{

    def f1 = 10
    def f2 {10}
    def f3 = {10}
    def f4() = 10
    def f5() {10}
    def f6() = {10}
    def f7 = () => 10
    def f8 = () => {10}
    def f9 = {() => {10}}

    def main(args: Array[String]){
        println(f1)     // 10
        println(f2)     // ()
        println(f3)     // 10
        println(f4)     // 10
        println(f4())   // 10
        println(f5)     // ()
        println(f5())   // ()
        println(f6)     // 10
        println(f6())   // 10
        println(f7)     // <function0>
        println(f7())   // 10
        println(f8)     // <function0>
        println(f8())   // 10
        println(f9)     // <function0>
        println(f9())   // 10
    }

}

objectnewmain扩展对象{
def f1=10
def f2{10}
def f3={10}
def f4（）=10
def f5（）{10}
def f6（）={10}
def f7=（）=>10
def f8=（）=>{10}
DEFF9={（）=>{10}
def main（参数：数组[字符串]）{
println（f1）//10
println（f2）/（）
println（f3）//10
println（f4）//10
println（f4（））//10
println（f5）/（）
println（f5（））/（）
println（f6）//10
println（f6（））//10
println（f7）//
println（f7（））//10
println（f8）//
println（f8（））//10
println（f9）//
println（f9（））//10
}
}

大概其中有些是等价的，有些是语法上的糖分，有些是我不应该使用的东西，但我一辈子都搞不清楚。我的具体问题是：

```
println（f2）
```
和
```
println（f5（））
```
如何给出
```
单位
```
？块中的最后一项不是
```
10
```
？它与给出
```
10
```
的
```
println（f3（））
```
有何不同
如果
```
println（f5）
```
给出
```
unit
```
，那么
```
println（f5（））
```
不应该是无效的，因为
```
unit
```
不是一个函数吗？这同样适用于
```
println（f6）
```
和
```
println（f6（））
```
在所有打印10的文件中：
```
f1
```
，
```
f3
```
，
```
f4
```
，
```
f4（）
```
，
```
f6
```
，
```
f6（）
```
，
```
f7（）
```
，
```
f8（）
```
，
```
f9（）
```
，它们之间是否存在功能上的差异（就其功能而言）或用法上的差异（就我应该何时使用哪一个而言）？或者它们都是等价的

第二种形式不使用赋值。因此，您可以将其视为一个过程。它并不意味着返回某些内容，因此返回Unit，即使最后一条语句可以用于返回特定的内容（但它可以是if语句，它只能在一个分支中有特定的内容）

这里不需要牙套。例如，如果定义val，则需要它们，因此此val的范围仅限于封闭块

def sqrGtX (n:Int, x: Int) = {
  val sqr = n * n
  if (sqr > x) 
    sqr / 2 
  else x / 2 
}

这里需要大括号来定义val sqr。如果val是在内部分支中声明的，则大括号不需要位于方法的顶层：

def foo (n:Int, x: Int) = 
  if (n > x) {
    val bar = x * x + n * n
    println (bar) 
    bar - 2  
  } else x - 2

为了进一步研究当两个方法返回相同的结果时，您可以编译它们并比较字节码。两个二进制相同的方法将是相同的

def f() {...}

糖是用来吃的吗

def f(): Unit = {...}

因此，如果省略“=”，该方法将始终返回Unit类型的对象。在Scala中，方法和表达式总是返回一些东西

def f() = 10
is sytactic sugar for
def f() = {
10
}

如果您写入def（）=（）=>10，则与写入相同

def f() = {
() => 10
}

这意味着f返回一个函数对象。不过你可以写

val f = () => 10

用f（）调用时，它返回10 在大多数情况下，函数对象和方法可以交替使用，但存在一些语法差异。例如当你写作时

def f() = 10
println(f)

val f = () => 10
println(f)

你得到“10”，但当你写

def f() = 10
println(f)

val f = () => 10
println(f)

你得到

<function0>

两个println将打印相同的内容

List(2,3,4)

当您在预期函数对象的位置使用方法名称，并且方法签名与预期函数对象的签名匹配时，它将自动转换。因此，

list.map（inc）

被scala编译器自动转换为

list.map(x => inc(x))

按顺序回答您的问题：

```
f2
```
和
```
f5（）
```
返回
```
单位
```
，因为scala将不带“
```
=
```
”的任何
```
def
```
作为返回
```
单位
```
的函数，而不管块中的最后一项是什么。这是一件好事，因为否则定义一个不返回任何内容的函数就不会太冗长

```
println（f5（））
```
是有效的，即使它返回
```
Unit
```
，因为在scala中
```
Unit
```
是一个有效的对象，尽管您不能实例化它<例如，code>Unit.toString（）是一个有效的语句（如果不是通常有用的话）
并非所有打印的
```
10
```
版本都相同。最重要的是，
```
f7
```
、
```
f8
```
和
```
f9
```
实际上是返回返回
```
10
```
的函数，而不是直接返回
```
10
```
。当您声明
```
def f8=（）=>{10}
```
时，您正在声明一个不带参数并返回一个不带参数并返回单个整数的函数
```
f8
```
。当您调用
```
println（f8）
```
时，
```
f8
```
会将该函数巧妙地返回给您。调用
```
println（f8（））
```
时，它返回函数，然后立即调用它
功能
```
f1
```
、
```
f3
```
、
```
f4
```
和
```
f6
```
在功能上基本相同，只是风格不同而已

正如“user unknown”所指出的，大括号仅在确定范围时才重要，在这里对您的用例没有任何影响。

六年后，在未来更进一步发布的Scala版本中，情况有所改善：

已将定义
```
f2
```
和
```
f5
```
删除为“”
无需参数即可调用
```
f4
```
```
f5
```
和
```
f6
```

这将我们定义函数的9种方式和调用函数的15种方式归纳为定义函数的7种方式和调用函数的10种方式：

object NewMain extends Thing{

    def f1 = 10
    def f3 = {10}
    def f4() = 10
    def f6() = {10}
    def f7 = () => 10
    def f8 = () => {10}
    def f9 = {() => {10}}

    def main(args: Array[String]){
        println(f1)     // 10
        println(f3)     // 10
        println(f4())   // 10
        println(f6())   // 10
        println(f7)     // <function0>
        println(f7())   // 10
        println(f8)     // <function0>
        println(f8())   // 10
        println(f9)     // <function0>
        println(f9())   // 10
    }
}

objectnewmain扩展对象{
def f1=10
def f3={10}
def f4（）=10
def f6（）={10}
def f7=（）=>10
def f8=（）=>{10}
def f9={（）
object NewMain extends Thing{

    def f1 = 10
    def f3 = {10}
    def f4() = 10
    def f6() = {10}
    def f7 = () => 10
    def f8 = () => {10}
    def f9 = {() => {10}}

    def main(args: Array[String]){
        println(f1)     // 10
        println(f3)     // 10
        println(f4())   // 10
        println(f6())   // 10
        println(f7)     // <function0>
        println(f7())   // 10
        println(f8)     // <function0>
        println(f8())   // 10
        println(f9)     // <function0>
        println(f9())   // 10
    }
}