Scala面向函数编程

 

函数式编程与命令式编程最大的不同其实在于：

函数式编程关心数据的映射，命令式编程关心解决问题的步骤

这里的映射就是数学上“函数”的概念——一种东西和另一种东西之间的对应关系。

这也是为什么“函数式编程”叫做“函数式编程”。

这是什么意思呢？

假如，现在你来到 google 面试，面试官让你把二叉树镜像反转一下（大雾

几乎不假思索的，就可以写出这样的 Python 代码：

def invertTree(root): if root is None: return None if root.left: invertTree(root.left) if root.right: invertTree(root.right) root.left, root.right = root.right, root.left return root

好了，现在停下来看看这段代码究竟代表着什么——

它的含义是：首先判断节点是否为空；然后翻转左树；然后翻转右树；最后左右互换。

这就是命令式编程——你要做什么事情，你得把达到目的的步骤详细的描述出来，然后交给机器去运行。

这也正是命令式编程的理论模型——图灵机的特点。一条写满数据的纸带，一条根据纸带内容运动的机器，机器每动一步都需要纸带上写着如何达到。

那么，不用这种方式，如何翻转二叉树呢？

函数式思维提供了另一种思维的途径——

所谓“翻转二叉树”，可以看做是要得到一颗和原来二叉树对称的新二叉树。

这颗新二叉树的特点是每一个节点都递归地和原树相反。

用 haskell 代码表达出来就是：

data Tree a = Nil | Node a (Tree a) (Tree a) deriving (Show, Eq) invert :: Tree a -> Tree a invert Nil = Nil invert (Node v l r) = Node v (invert r) (invert l)

（防止看不懂，翻译成等价的 python ）

def invert(node): if node is None: return None else return Tree(node.value, invert(node.right), invert(node.left))

这段代码体现的思维，就是旧树到新树的映射——对一颗二叉树而言，它的镜像树就是左右节点递归镜像的树。

这段代码最终达到的目的同样是翻转二叉树，但是它得到结果的方式和 python 代码有着本质的差别：通过描述一个 旧树->新树 的映射，而不是描述“从旧树得到新树应该怎样做”来达到目的。

那么这样思考有什么好处呢？

首先，最直观的角度来说，函数式风格的代码可以写得很精简，大大减少了键盘的损耗（

更重要的是，函数式的代码是“对映射的描述”，它不仅可以描述二叉树这样的数据结构之间的对应关系，任何能在计算机中体现的东西之间的对应关系都可以描述——比如函数和函数之间的映射（比如 functor）；比如外部操作到 GUI 之间的映射（就是现在前端热炒的所谓 FRP）。它的抽象程度可以很高，这就意味着函数式的代码可以更方便的复用。

上述观点来自于：https://hcyue.me/2016/05/14/%E4%BB%80%E4%B9%88%E6%98%AF%E5%87%BD%E6%95%B0%E5%BC%8F%E7%BC%96%E7%A8%8B%E6%80%9D%E7%BB%B4/

简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。

它属于"结构化编程"的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：

　　(1 + 2) * 3 - 4

传统的过程式编程，可能这样写：

　　var a = 1 + 2;

　　var b = a * 3;

　　var c = b - 4;

函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：

　　var result = subtract(multiply(add(1,2), 3), 4);

这就是函数式编程。

1.第一等公民

"第一等公民"（first class），指的是函数与其他数据类型一样，处于平等地位，可以赋值给其他变量，也可以作为参数，传入另一个函数，或者作为别的函数的返回值。

//      函数常量以括号括起来的逗号分隔的参数列表开头，后跟箭头和函数体。

lambda匿名函数：

  val add = (x: Int, y: Int) => x + y  // 匿名函数
  println(add(1, 100))

 高级函数指的是以函数做参数或者返回值是一个函数的函数。

  def operation(functionParams: (Int, Int)=> Int){ // 函数作为参数传给另外一个函数
    println(functionParams(4, 19))
  }
  val multiply = (x: Int, y:Int) => x*y
  operation(add)  // 23
  operation(multiply) // 76 
  
  val anotherAdd = add // 将其赋值给一个变量
  println(anotherAdd(19, 20)) // 39 
  
  val li = List.range(1, 10) // 和python一样， 打印出1-9的数
  print(li)
  println(li.filter((x: Int) => x%2==0)) // List(2, 4, 6, 8) , 匿名函数做为参数
  println(li.filter(x => x%2==0))
  println(li.filter(_%2==0)) // List(2, 4, 6, 8)

2, 闭包

Scala中的闭包捕获到的是变量的本身而不仅仅是变量的数值,当自由变量发生变化时，Scala中的闭包能够捕获到这个变化. 

  var anotherParams = 90
  val addAnother = (x: Int) => x + anotherParams
  println(addAnother(10)) // 100
  anotherParams = 40
  println(addAnother(10)) // 50 

3.偏函数：

未提供默认参数的地方使用下划线替代，从而创建出一个“函数值”，在使用这个函数值（部分应用函数）的时候，只需提供下划线部分对应的参数即可.

  val sum1 = (x: Int, y: Int, z: Int) => x+y+z
  val f: Int => Int = sum1(12, 35, _: Int) // 下划线的值是代表需要用户提供的
  println(f(100)) //  147
  val f1: (Int, Int) => Int = sum1(_: Int, _: Int, 12) // 定义1 个已知的参数
  println(f1(19, 20)) //  51

 

4.函数柯里化：

curry化最大的意义在于把多个参数的function等价转化成多个单参数function的级联，这样所有的函数就都统一了，方便做lambda演算。 在scala里，curry化对类型推演也有帮助，scala的类型推演是局部的，在同一个参数列表中后面的参数不能借助前面的参数类型进行推演，curry化以后，放在两个参数列表里，后面一个参数列表里的参数可以借助前面一个参数列表里的参数类型进行推演。这就是为什么 foldLeft这种函数的定义都是curry的形式  

  def sum2(x: Int) = (y: Int) => println(x+y)
  sum2(12)(12) // 24
  def sum(x: Int = 18)(y:Int) = println(x+y)
  sum(12)(90)

5.递归函数

  def function(params: Int):Unit = {
    if(params < 10 && params >= 0){
      println(s"params: $params")
      function(params + 1)
    }
  }
  function(1)  // 打印出 1- 9

Scala编译器优化了尾递归调用，递归调用和执行一个while循环没有性能上区别。

 

参考：http://www.ruanyifeng.com/blog/2012/04/functional_programming.html

项目推荐：

2000多G的计算机各行业电子资源分享（持续更新）

2020年微信小程序全栈项目之喵喵交友【附课件和源码】

Spring Boot开发小而美的个人博客【附课件和源码】

Java微服务实战296集大型视频-谷粒商城【附代码和课件】

Java开发微服务畅购商城实战【全357集大项目】-附代码和课件

最全最详细数据结构与算法视频-【附课件和源码】