Scala 中 def foo = {} 和 def foo() = {} 有什么区别？

Question

鉴于以下在 Scala 中定义函数的结构，您能否解释一下其中的区别以及含义是什么？

def foo = {}

与

def foo() = {}

更新

感谢您的快速回复。这些都很棒。对我来说唯一的问题是：

如果我省略括号，是否还有办法传递函数？这是我在 repl 中得到的内容：

scala> def foo = {}
foo: Unit

scala> def baz() = {}
baz: ()Unit

scala> def test(arg: () => Unit) = { arg }
test: (arg: () => Unit)() => Unit

scala> test(foo)
<console>:10: error: type mismatch;
 found   : Unit
 required: () => Unit
              test(foo)
                   ^

scala> test(baz)
res1: () => Unit = <function0>

---

更新 2012-09-14

以下是我注意到的一些类似问题：

1. 带括号和不带括号的函数之间的区别
2. Scala 方法没有参数

Answer 1

如果您在定义中包含括号，则可以选择在调用该方法时省略它们。如果在定义中省略它们，则在调用方法时将无法使用它们。

scala> def foo() {}
foo: ()Unit

scala> def bar {}
bar: Unit

scala> foo

scala> bar()
<console>:12: error: Unit does not take parameters
       bar()
          ^

此外，您可以对高阶函数执行类似的操作：

scala> def baz(f: () => Unit) {}
baz: (f: () => Unit)Unit

scala> def bat(f: => Unit) {}
bat: (f: => Unit)Unit

scala> baz(foo)    

scala> baz(bar)
<console>:13: error: type mismatch;
 found   : Unit
 required: () => Unit
       baz(bar)
           ^
scala> bat(foo)

scala> bat(bar)  // both ok

这里 baz 将仅采用 foo() 而不是 bar。这个有什么用，我不知道。但它确实表明类型是不同的。

Answer 2

让我复制我在重复的问题：

0 元数的 Scala 2.x 方法可以使用或不使用括号 () 进行定义。这用于向用户发出信号，表明该方法有某种副作用（例如打印到标准输出或破坏数据），而不是没有副作用，稍后可以将其实现为 val 。

请参阅Scala 编程：

这种无参数方法在 Scala 中很常见。相比之下，使用空括号定义的方法（例如 def height(): Int）称为空括号方法。推荐的约定是，只要没有参数，就使用无参数方法，并且该方法仅通过读取包含对象的字段来访问可变状态（特别是，它不会更改可变状态）。

该约定支持统一访问原则[...]

总而言之，Scala 中鼓励将不带参数且无副作用的方法定义为无参数方法，即省略空括号。另一方面，您永远不应该定义一个没有括号的有副作用的方法，因为这样该方法的调用看起来就像一个字段选择。

术语

0 元数方法有一些令人困惑的术语，因此我将在此处创建一个表：

	用 Scala 编程	scala/scala 术语
def foo: Int	无参数方法	nullary method
def foo(): Int	空括号方法	nilary method

我说“nullary method”听起来很酷，但人们经常说错，读者也会感到困惑，所以我建议坚持使用无参数方法与空括号方法，除非你在拉取请求时人们已经在使用这些术语。

() 在 Scala 2.13 或 3.0 中不再是可选的

伟大的 () 插入， Martin Odersky 对 Scala 3 进行了更改，要求 () 调用使用 () 定义的方法。这记录在 Scala 3迁移指南为：

自动应用是调用空方法而不传递空参数列表的语法。

注意：迁移文档中的术语有误。它应该读作：

自动应用是调用empty-paren（或“nilary”）方法而不传递空参数列表的语法。

Scala 2.13 遵循 Scala 3.x，并弃用了 Eta-expand 中空括号方法的自动应用如果预期类型为 Function0，则为 0-arity 方法。此规则的一个值得注意的例外是 Java 定义的方法。我们可以继续调用Java方法，例如不使用()的toString。

Answer 3

要回答第二个问题，只需添加 _：

scala> def foo = println("foo!")
foo: Unit

scala> def test(arg: () => Unit) = { arg }
test: (arg: () => Unit)() => Unit

scala> test(foo _)
res10: () => Unit = <function0>

scala> test(foo _)()
foo!

scala>            

Answer 4

我建议始终以如下函数开始定义：

def bar {}

并且仅在某些情况下，当您被迫时，将其更改为：

def bar() {}

原因：让我们从可能的使用角度考虑这两个函数。如何获取它们的信息以及可以将它们传递到哪里。

我根本不会称其为函数：

def bar {}

它可以被调用为：

bar

但不能作为函数：

bar()

当我们定义带有按名称调用参数的高阶函数时，我们可以使用这个栏：

def bat(f: => Unit) {
    f //you must not use (), it will fail f()
}

我们应该记住，<代码>=> Unit - 甚至不是一个函数。您绝对不能像使用函数一样使用 thunk，因为您不能选择将其视为要存储或传递的函数值。您只能触发对实际参数表达式（任意数量）的求值。
Scala：将函数作为代码块传递大括号之间

用() 定义的函数有更大的使用范围。它可以在相同的上下文中与 bar 完全相同地使用：

def foo() = {}
//invokation:
foo
//or as a function:
foo()

它可以传递到带有按名称调用参数的函数中：

bat(foo)

此外，如果我们定义一个高阶函数，它接受不是一个按名称调用的 pamameter，而是一个真正的函数：

def baz(f: () => Unit) {}

我们还可以将 foo 传递给 baz：

baz(foo)

正如我们所看到的标准函数，如 foo code>有更大的使用范围。但是使用不带 () 定义的函数加上定义接受按名称调用参数的高阶函数，让我们可以使用更清晰的语法。

如果您不尝试归档更好、更具可读性的代码，或者如果您需要能够将代码片段传递给使用按名称调用参数定义的函数和使用真实函数定义的函数，那么定义您的代码函数作为标准函数：

def foo() {}

如果您喜欢编写更清晰易读的代码，并且您的函数没有副作用，请将函数定义为：

def bar {}

另外尝试定义您的高阶函数以接受按名称调用参数，但是不是一个函数。
只有在迫不得已的情况下，才使用前面的选项。