Scala学习笔记3 （Functional Programming）

3.   FP

3.1.     函数

函数的地位和一般的变量是同等的，可以作为函数的参数，可以作为返回值。

传入函数的任何输入是只读的，比如一个字符串，不会被改变，只会返回一个新的字符串。

 

Java里面的一个问题就是很多只用到一次的private方法，没有和使用它的方法紧密结合；Scala可以在函数里面定义函数，很好地解决了这个问题。

3.1.1.  函数定义

函数和方法一般用def定义；也可以用val定义匿名函数，或者定义函数别名。

def m0(x:Int) = x*x

val m1 = (x:Int)=> x*x // 用(), ()是必须的

val m2 = {x:Int=> x*x} // 用{}, {}是必须的

m0(10) // 100

m1(10) // 100

m2(10) // 100

 

不需要返回值的函数，可以使用def f() {...}，永远返回Unit（即使使用了return）,即：

    def f() {...}  等价于 def f():Unit = {...}

例如：

def f() { return "hello world" }

f() // Unit，而不是 "hello world"

 

需要返回值的函数，用 def f() = {...} 或者 def f = {...}

def f() = { "hello world" }

f() // "hello world"

def f = { "hello world" } // f是匿名函数 {"hello world"}的别名

f // "hello world"

 

三种定义方式的区别：

def f() { return .. }	调用：f, f()皆可	始终返回：Unit
def f() = ...	调用：f, f()皆可	返回Unit或者值
def f = ...	调用：f	返回Unit或者值

 

提示：函数式风格——尽量编写有返回值的函数; 尽量简短（函数体不使用{...}）

 

3.1.2.  映射式定义

一种特殊的定义：映射式定义（直接相当于数学中的映射关系）;

其实也可以看成是没有参数的函数，返回一个匿名函数；调用的时候是调用这个返回的匿名函数。

 

例子1：

def f:Int=>Double = { // 请看做 def f: (Int=>Double) = {...}

    case 1 => 0.1

    case 2 => 0.2

    case _ => 0.0

}

f(1) // 0.1

f(3) // 0.0

 

例子2：

def m:Option[User]=>User = {

    case Some(x) => x

    case None => null

}

m(o).getOrElse("none...")

 

例子3：(多->1)

def m:(Int,Int)=>Int = _+_

m(2,3) // 5

 

例子4：

def m:Int=>Int = 30+  // 相当于30+_,如果唯一的"_"在最后,可以省略

m(5) // 35

3.1.3.  特殊函数名 + - * /

方法名可以是*：

def *(x:Int, y:Int) = { x*y }

*(10,20) // = 200

1+2, 相当于1.+(2)

 

定义一元操作符（置前）可用unary_。

注：unary ：一元的，单一元素的, 单一构成的 。发音：【`ju: ne ri】

 

-2，相当于：(2).unary_- // -2

+2，相当于：(2).unary_+ // 2

!true, 相当于：(true).unary_! // false

~0，相当于 (0).unary_~  // -1

3.1.4.  缺省参数、命名参数

注意：从Scala2.8开始支持。

请对比以下两种写法的可读性：

一般函数调用	命名函数调用
sendEmail( "jon.pretty@example.com", List("recipient@example.com"), "Test email", b, Nil, Nil, Nil)	sendEmail(     body = b,     subject = "Test email",     to = List("recipient@example.com"),     from = "jon.pretty@example.com",     attachments = List(file1, file2) )

 

定义和使用：

def join(a:List[String], s:String="-") = { a.mkString(s) }

join(List("a","b","c")) // a-b-c

join(List("a","b","c"), ":") // a:b:c

调整参数调用顺序：

join(s=":",a=List("a","b","c")) // a:b:c

 

3.1.5.  函数调用

def f(s: String = "default") = { s }

f // "hello world"

f() // "hello world"

 

Ø  对象的无参数方法的调用，可以省略.和()

"hello world" toUpperCase // "HELLO WORLD"

 

Ø  对象的1个参数方法的调用，可以省略.和()

"hello world" indexOf w // 6

"hello world" substring 5 // "world"

Console print 10 // 但不能写 print 10，只能print(10)，省略Console.

1 + 2 // 相当于 (1).+(2)

 

Ø  对象的多个参数方法的调用,也可省略.但不能省略()：

"hello world" substring (0, 5) // "hello"

 

注意：

l  不在class或者object中的函数不能如此调用：

def m(i:Int) = i*i

m 10 // 错误

l  但在class或者object中可以使用this调用：

object method {

    def m(i:Int) = i*i

    def main(args: Array[String]) = {

        val ii = this m 15  // 等同于 m(15), this 不能省略

        println(ii)

    }

}

 

提示：这种调用方法最大的用途在于操作符重载，以及阅读性强的DSL。

例子：

    System exit 0

    Thread sleep 10

    Console println "hello world" // 省略Console则报错

    2 ** 10

    "-" * 100

 

3.1.6.  匿名函数

形式：((命名参数列表)=>函数实现)(参数列表)

特殊地：

l  无参数： (()=>函数实现)()

l  有一个参数且在最后： (函数实现)(参数)

l  无返回值： ((命名参数列表)=>Unit)(参数列表)

 

有参数的匿名函数（参数名称不能省）：

((i:Int)=> i*i)(3) // 9

((i:Int, j:Int) => i+j)(3, 4) // 7

 

有一个参数且在最后的：

(10*)(2) // 20, 相当于 ((x:Int)=>10*x)(2)

(10+)(2) // 12, 相当于 ((x:Int)=>10+x)(2)

(List("a","b","c") mkString)("=") // a=b=c

 

无参数的匿名函数：

(()=> 10)() // 10

 

无参数无返回值：

(() => Unit)

( ()=> {println("hello"); 20*10} )()

{ println("hello"); 20*10 }

 

例子1：

def m = (i:Int)=> i*i

m(3) // 9

List(1,2,3,4).map(m) // List(1, 4, 9, 16)

 

例子2：

def times3(m: ()=> Unit) = { m();m();m() }

times3 ( ()=> println("hello world") )

由于是无参数的匿名函数，可进一步简化：

def times3(m: =>Unit) = { m;m;m } // 参见“lazy参数”

times3 ( println("hello world") )

注：大量的匿名函数增加了代码的阅读难度。看到符号=>就要想到函数

 

3.1.7.  偏函数

用下划线代替1+个参数的函数叫偏函数（partially applied function），如：

def sum(a:Int,b:Int,c:Int) = a+b+c

val p0 = sum _ // 正确

val p1 = sum(10,_,20) // 错误

val p2 = sum(10,_:Int,20) // 正确

val p3 = sum(_:Int,100,_:Int)

p0(1,2,3) // 6

p2(100) // 130

p3(10,1) // 111

或者：

  (sum _)(1 2 3) // 6

  (sum(1,_:Int,3))(2) // 6

  (sum(_:Int,2,_:Int))(1,3) // 6

从上面可以看出，partial函数是一个正常函数中抽出来的一部分（参数不全），故称为partial函数。

3.1.8.  “_”匿名参数

_：匿名函数中的匿名参数

注意：多个下划线指代多个参数，而不是单个参数的重复使用。第一个下划线代表第一个参数，第二个下划线代表第二个，第三个……，如此类推。

 

Java：

int add(int i, int j) { return i+j; }

add(3,4)

返回值、函数名和return关键字可以省略，变为：

 

scala 写法1：

((i:Int, j:Int) => i+j)(3, 4) // 7

i,j变量名可以省略，变为：

 

scala写法2：

    ((_:Int) + (_:Int))(3,4) // 7

    注意：括号(_:Int)括号是必须的

 

其他例子：

"Hello".exists(_.isUpper) // true

例子2：

def sum(x:Int,y:Int,z:Int) = x+y+z

val sum1 = sum _

val sum2 = sum(1000,_:Int,100)

sum1(1,2,3) // 6

sum2(5) // 1105

 

如果_在最后，还可以省略

1 to 5 foreach println

1 to 5 map (10*)

1 to 5 map (*10) // 错误！_不在最后不能省

3.1.9.  变长参数 *

变长参数只能放在最后一个，否则就歧义了，

def sum(ns:Int*, s:String) = ... // 错误

例子1：

def sum(ns: Int*) = {

    var s = 0

    for (n<-ns) s += n

    s

}

sum(1,2,3,4) // 10

更函数化的写法：

def sum(ns:Int*) = ns.reduceLeft(_+_)

sum(1,2,3,4) // 10

 

例子2：

def m(args:Any*) = args foreach println

scala> m(3,3.14,"hello",List(1,2,3))

3

3.14

hello

List(1, 2, 3)

 

3.1.10.      lazy参数

就是调用时用到函数的该参数，每次都重新计算：

例子1：自定义loop

def loop2 (cond: =>Boolean)(body: =>Unit): Unit =

  if (cond) { body; loop2(cond)(body) }

调用：

var i=0; loop2 (i<3) (i+=1) // i=3

或者

var i=0; loop2 {i<3} {i+=1} // i=3

或者我们更习惯的方式:

var i=0; loop2 (i<3) {i+=1}

 

例子2：自定义loop..until

def loop3 (body: =>Unit): foo = new foo(body)

class foo(body: =>Unit) {

  def until(cond: =>Boolean) { body; if(!cond) until(cond) }

}

//调用：

var i = 0

loop3 { i+=1; println(i) } until (i>3)

 

3.2.     函数式编程

3.2.1.  风格

首选使用val，用var之前要仔细考虑是否真正需要。

非函数式	函数式
var s = "" if (args.length>0) s = args[0]	val s = if (args.length>0) args[0] else ""
def gcd(a0:Int,b0:Int) = {   var a = a0; var b = b0   while(a!=0) { val t = a a = a % b b = t   }   return b }	求a，b的最大公约数,所有的while循环基本都可以被替代： def gcd(a:Int,b:Int) = if (b==0) a else gcd(b, a % b)

 

函数要短，可以试着所有的函数体都没有 {...} 包围，一旦出现，尽量分解

 

例如打印

1  2  3

2  4  6

3  6  9

非函数式	函数式
for(i<-1 to 3; j<-1 to 3) { print(i*j + " "); if (j==3) println }	def f(n:Int) = 1 to 3 map (_*n) mkString " " 1 to 3 map f mkString "\n"

 

3.2.2.  函数作为参数

采用映射式函数定义：

例子1：

def f(x:Int, y:Int, m:(Int, Int)=>Int) = m(x,y)

f(3,4, (x,y)=>x+y) // 7

f(3,4, (x,y)=>scala.math.sqrt(x*x+y*y)) // 5

例子2：

def f(x:Int, y:Int, m: =>Unit) = { println(x*y); m } 

f(3,4, println("end"))

// 12

// end

例子3：

  def f(f2:Int=>Int) = f2(5)

  f(100+) // 105, 100+是匿名函数 ((x:Int)=>100+x)的简写

3.2.3.  函数作为返回值

def f(s:String):(Int => String) = { n:Int=> s * n }

f("*") // res32: (Int) => String = <function1>

res32(10) // "**********"

f("*")(10) // 相当于先得到f("*")的返回值函数，再用该返回值函数调用一个参数

3.2.4.  Curry化

例如：

def sum(a:Int, b:Int) = { a + b } // sum(1, 2) = 3

Curry化后：

def sum(a:Int)(b:Int) = { a + b } // sum(1)(2) = 3

或者：

def sum(a:Int) = { (b:Int)=> a + b } // sum(1)(2) = 3

// 调用方式二：val t1 = sum(10);  val t2 = t1(20)

 

3.2.5.  递归

使用递归的原因：

其一是很多数学关系、逻辑关系本身就是递归描述（Hanoi、Fib）的；

其二是函数式编程不鼓励用变量循环，而是用递归。

递归包含递归出口和递归体：

递归出口	即递归的终止条件 比如0!=1, fib(1)=fib(2)=1, index==1000
递归体	即和前面或后面的值之间的关系 比如n! = n*(n-1)!, fib(n)=fib(n-2)+fib(n-1)

 

例子1：幂运算

如计算2^100, scala.math.pow(2,2000)越界，可用递归

def pow(n:BigInt, m:BigInt):BigInt = if (m==0) 1 else pow(n,m-1)*n

 

例子2：Hanoi汉诺塔

从a挪到c

a(from)	b(via)	c(to)
=     --- 1 ===   =====   --- n-1 =======  --- n
=======  --- n	=     --- 1 ===   =====   --- n-1
	=     --- 1 ===   =====   --- n-1	=======  --- n
		=     --- 1 ===   =====   --- n-1 =======  --- n

def move(n:Int, a:Int, b:Int, c:Int) = {

  if (n==1) println("%s to %s" format (a, c)) else {

move(n-1, a,c,b); move(1,a,b,c); move(n-1,b,a,c) }}

例子3：最大公约数

12  20

    20  12 (=12%20)

12  8 (=20%12)

        8  4 (=12%8)

           4  0 (=8%4)

def gcd(n:Int, m:Int):Int = if(m==0) n else gcd(m, n%m)

 

例子4：上台阶

上N级台阶，即可每次1步也可每次2步走，共有多少种不同走法

解法：迈出第一步有两种方法，第一步后就是N-1和N-2的走法了

def step(n:Int):Int = if (n<=2) n else step(n-1)+step(n-2)

推广：如果每次可走1步或2步或3步，则

def step(n:Int):Int = n match { case 1=>1; case 2=>2; case 3=>4;

case _ =>step(n-1)+step(n-2)+step(n-3) }

3.2.6.  尾-递归

定义：函数尾（最后一条语句）是递归调用的函数。

tail-recursive会被优化成循环，所以没有堆栈溢出的问题。

 

线性递归的阶乘：

def nn1(n:Int):BigInt = if (n==0) 1 else nn1(n-1)*n

println(nn1(1000)) // 4023...000

println(nn1(10000)) // 崩溃：（

 

尾递归的阶乘：

def nn2(n:Int, rt:BigInt):BigInt = if (n==0) rt else nn2(n-1, rt*n)

println(nn2(1000,1)) // 40...8896

println(nn2(10000,1)) // 2846...000

 

def nn3(n:Int):BigInt = nn2(n,1)

 

对比：

线性递归	尾递归
nn1(5)   {5 * nn1(4) } {5 * {4 * nn1(3) }} {5 * {4 * {3 * nn1(2) }}} {5 * {4 * {3 * {2 * nn1(1) }}}} {5 * {4 * {3 * {2 * 1}}}} {5 * {4 * {3 * 2}}} {5 * {4 * 6}} {5 * 24} 120	nn2(5, 1) nn2(4, 1*5=5) nn2(3, 4*5=20) nn2(2, 3*20=60) nn2(1, 2*60=120) 120
不算，直到递归到一个确定的值后，又从这个具体值向后计算；更耗资源,每次重复的调用都使得调用链条不断加长. 系统使用栈进行数据保存和恢复	每递归一次就算出相应的结果。
不能优化成循环	可以优化成循环

 

例子：查找第10001个质数：

def prime(n:Int) = 2 to math.sqrt(n).toInt forall (n%_!=0)

def next(p:Int) = p+1 to 2*p find prime get

def f(p:Int, i:Int):Int = if (i==10001) p else f(next(p), i+1)

f(2,1) // 104743

或者使用Stream：

def f2(p:Int):Stream[Int] = p #:: f2(next(p))

f2(2).take(10001).last // 104743

 

例子：fib数列(1 1 2 3 5 8 13 21)

def fib2(n1:BigInt, n2:BigInt, i:Int, n:Int):BigInt =

  if (i==n) n1 else fib2(n2, n1+n2, i+1, n)

def fib(n:Int) = fib2(1,1,0,n)

0 to 10 map fib

fib(100-1) // 第100个fib数=354224848179261915075