scala之method和function的区别

在我没有学习scala的时候，主要用java和python作平常工做开发，印象中，没有特别的刻意的去区分method和function的区别，这个关系，正如咱们平常生活中，没有刻意的去区分质量和重量。可是，他们之间，的确是有所不一样的，这些不一样也是创建在他们之间有联系的基础之上！

 

1. 如何定义

首先，仍是引用英文原文来看看他们在定义上的区别和联系吧：

A Function Type is (roughly) a type of the form (T1, ..., Tn) => U, which is a shorthand for the trait FunctionN in the standard library. Anonymous Functions and Method Values have function types, and function types can be used as part of value, variable and function declarations and definitions. In fact, it can be part of a method type.

A Method Type is a non-value type. That means there is no value - no object, no instance - with a method type. As mentioned above, a Method Value actually has a Function Type. A method type is a def declaration - everything about a def except its body.

 

2. 具体例子分析

1 scala> def m1(x:Int) = x+3
2 m1: (x: Int)Int　　　　
3 
4 scala> val f1 = (x: Int) => x+3
5 f1: Int => Int = <function1>

看到没，方法定义和函数定义是否是在scala的解析器signature上就有显示了，def m1(x: Int) = x+3就是一个简单的method的定义。signature中m1: (x: Int)Int　表示method m1有一个参数Int型参数x，返回值是Int型。

val f1 = (x: Int) => x+3则是function的定义，解析器的signature中f1: Int => Int = <function1>表示function f1的method体接受一个Int型的参数，输出结果的类型是Int型。

从上面的例子，得出一个总结：

方法是一个以def开头的带有参数列表（能够无参数列表）的一个逻辑操做块，这正如object或者class中的成员方法同样。

函数是一个赋值给一个变量（或者常量）的匿名方法（带或者不带参数列表），而且经过=>转换符号跟上逻辑代码块的一个表达式。=>转换符号后面的逻辑代码块的写法与method的body部分相同。

 

3. 区别都还有那些？

method能够做为一个表达式的一部分出现（调用函数并传参），可是method（带参方法）不能做为最终的表达式（无参方法能够，可是这个就成了方法调用，由于scala容许无参方法调用时省略（）括号），而function能够做为最终的表达式出现。

1 scala> m1
2 <console>:12: error: missing arguments for method m1;
3 follow this method with `_' if you want to treat it as a partially applied function
4        m1
5        ^
6 
7 scala> f1
8 res1: Int => Int = <function1>

  

method能够没有参数列表，参数列表也能够为空。可是function必须有参数列表（也能够为空）。方法名意味着方法调用，函数名只是表明函数自身

 1 scala> def m2 = 100;
 2 m2: Int
 3 
 4 scala> def m3() = 1000;
 5 m3: ()Int
 6 
 7 scala> var f2 = => 100;
 8 <console>:1: error: illegal start of simple expression
 9 var f2 = => 100;
10          ^
11 
12 scala> var f2 =()=> 100;
13 f2: () => Int = <function0>

 1 scala> m2
 2 res2: Int = 100
 3 
 4 scala> m3
 5 res3: Int = 1000
 6 
 7 scala> m3()
 8 res4: Int = 1000
 9 
10 scala> f2
11 res5: () => Int = <function0>
12 
13 scala> f2()
14 res6: Int = 100

 

在函数出现的地方咱们能够提供一个方法。 这是由于，若是指望出现函数的地方咱们提供了一个方法的话，该方法就会自动被转换成函数。该行为被称为ETA expansion。 注意： 指望出现函数的地方，咱们可使用方法。 不指望出现函数的地方，方法并不会自动转换成函数 在scala中操做符被解释称方法：　　 前缀操做符：op obj 被解释称obj.op 中缀操做符：obj1 op obj2被解释称obj1.op(obj2) 后缀操做符：obj op被解释称obj.op

 1 scala> val ml = List(1,2,3,4)
 2 ml: List[Int] = List(1, 2, 3, 4)
 3 
 4 scala> ml.map((x)=>2*x)
 5 res0: List[Int] = List(2, 4, 6, 8)
 6 
 7 scala> def m(x:Int) = 2*x
 8 m: (x: Int)Int
 9 
10 scala> ml.map(m)
11 res1: List[Int] = List(2, 4, 6, 8)
12 
13 scala> def m(x:Int) = 3*x
14 m: (x: Int)Int
15 
16 scala> ml.map(m)
17 res2: List[Int] = List(3, 6, 9, 12)

 

能够在方法名后面加一个下划线强制变成函数。 注意： 方法名与下划线之间至少有一个空格哟！

 1 scala> def m3(x: Int): Int = x * x * x
 2 m3: (x: Int)Int
 3 
 4 scala> val f3 = m3_
 5 <console>:10: error: not found: value m3_
 6        val f3 = m3_
 7                 ^
 8 
 9 scala> val f3 = m3 _
10 f3: Int => Int = <function1>
11 
12 scala> f3(3)
13 res0: Int = 27