从本节开始我们会介绍如何使用Scala进行函数编程，在这之前希望你能对Scala的基础语法有所了解。其中我们会接触一些语法概念，例如：
- 尾递归函数（tail recusive function）
- 高阶函数 （HOF）
- 类型多态（type polymoriphc）
先来看一个简单的例子：
object MyModule {
def abs(n: Int): Int =
if (n < 0) -n
else n
private def formatAbs(n: Int): String = {
val msg = "The absolute value of %d is %d"
msg.format(n, abs(n))
}
def main(args: Array[String]): Unit = {
println(formatAbs(-12))
}
}
上面的代码非常简单，其中abs函数返回输入数值的绝对值；formatAbs函数计算输入数值的绝对值并返回一串说明的字符串；main函数为程序的入口并打印formatAbs函数的执行结果。
高阶函数
在Scala中我们必须接受一个新的概念，那就是函数也是值。他和其他的类型值一样，可以赋值给一个变量，可以存储在数据结构里，可以作为一个函数的入参也可以作为一个函数的返回值。如果一个函数有函数作为入参或者一个函数的返回值是函数则被称为高阶函数。高阶函数在函数式编程模式里非常重要，在接下来的章节里，我们会见识到他的威力。现在我们先来看一个尾递归函数的例子：
def factorial0(n: Int): Int = {
var a = n
var acc = 1
while (a > 0) {
acc *= a
a -= 1
}
acc
}
def factorial1(n: Int): Int = {
if (n <= 0) 1
else n * factorial1(n - 1)
}
def factorial2(n: Int): Int = {
@scala.annotation.tailrec
def go(n: Int, acc: Int): Int =
if (n <= 0) acc
else go(n - 1, n * acc)
go(n, 1)
}
上面有三个方法，其中factorial0是以循环的方式来实现阶乘，这符合我们习惯的命令式编程写代码的方式；factorial1是以递归的方式来实现阶乘，这个和我们在数学上定义阶乘的方式很像，但是这里存在一个问题就是，假如n很大factorial1方法执行的时候会栈溢出（StackOverflow），这是因为递归函数会消耗栈内存，递归层级较深时就会出现栈内存不足的情况；factorial2是以尾递归的方式来实现阶乘，那什么是尾递归？递归调用发生在尾部的递归及为尾递归，例如factorial2中go方法，递归调用的时候调用的是go方法本身。尾递归有什么优势呢？Scala编译器能够检查出尾递归并优化成while循环的字节码，这样可以避免像factorial1方法一样出现栈溢出。那么怎么样把一个普通递归方法改造成尾递归方法呢？诀窍就在于定义一个辅组函数go，并把每一步的中间结果作为方法的入参。让我们看一道练习：
\\使用递归来实现斐波那契数
def fib0(n: Int): Int = {
if (n <= 1) 0
else if (n == 2) 1
else fib0(n - 2) + fib0(n - 1)
}
\\使用递归来实现斐波那契数
def fib1(n: Int): Int = {
@scala.annotation.tailrec
def go(curr: Int, next: Int, count: Int): Int = {
if (count >= n) curr
else go(next, curr + next, count + 1)
}
go(0, 1, 1)
}
从上面的代码可以看出使用普通递归实现的fib0更接近于数学上的定义；而使用尾递归可以避免堆栈溢出。那么普通递归是如何转化成尾递归的呢？关键是添加辅助方法go以及设定辅助方法的入参，fib0中的两个中间状态fib0(n - 2) ，fib0(n - 1)分别对应着go方法入参curr和next，计数量n对应着入参count。
第一个高阶函数
我们已经定义了求绝对值的方法，又定义了求阶乘和斐波那契数的方法，那么我们可以定义同formatAbs类似的format方法，代码如下：
private def formatAbs(n: Int): String = {
val msg = "The absolute value of %d is %d"
msg.format(n, abs(n))
}
private def formatFactorial(n: Int): String = {
val msg = "The factorial of %d is %d"
msg.format(n, factorial2(n))
}
private def formatFib(n: Int): String = {
val msg = "The absolute value of %d is %d"
msg.format(n, fib1(n))
}
如果我们对比这三个方法就会发现这三个方法的实现基本是一样的，那么可以抽象出一个更加通用的方法吗？我们可以尝试一下：
def formatResult(name: String, n: Int, f: Int => Int): String = {
val msg = "The %s of %d is %d"
msg.format(name, n, f(n))
}
val msg1 = formatResult("abs value", -12, Math.abs)
val msg2 = formatResult("factorial", 5, factorial2)
val msg3 = formatResult("fib value", 6, fib1)
这其中的函数formatResult便是一个高阶函数，使用formatResult我们可以替换掉方法formatAbs，formatFactorial，formatFib。他有一个入参f，描述的就是一个输入为Int输出为Int的函数，Int => Int表示他的类型，这其实是Function1[Int, Int]类型。看到这里熟悉设计模式的同学可能会看到策略模式的影子。这里我们没有定义一个策略接口，实现三种策略类并将对应的对象作为formatResult的入参，因为函数f即可表示对应的策略，他可以是绝对值abs，可以是阶乘factorial2，也可以是斐波那契数fib1。这就是高阶函数的威力，函数作为值来传递比传递对象更加细颗粒，于是传统的设计模式在这里开始变了一个模样。
