【转】函数式编程（续）

以前已经有一篇文章是讲了函数式编程

http://www.cnblogs.com/charlesblc/p/6110484.html

 

今天又翻到了ruanyifeng的文章

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

正好复习一下。

 

诞生50多年以后，函数式编程（functional programming）开始得到愈来愈多的关注。

不只最古老的函数式语言Lisp重获青春，并且新的函数式语言层出不穷，好比Erlang、clojure、Scala、F#等等。目前最当红的Python、Ruby、Javascript，对函数式编程的支持都很强，就连老牌的面向对象的Java、面向过程的PHP，都忙不迭地加入对匿名函数的支持。愈来愈多的迹象代表，函数式编程已经再也不是学术界的最爱，开始大踏步地在业界投入实用。

 

注：Java中的匿名函数是 Java8开始支持的。指的就是Lambda表达式，又称为闭包或匿名函数。

在C语言中的概念相似于一个函数指针，这个指针能够做为一个参数传递到另一个函数中。

因为Java是相对较为面向对象的语言，一个Java对象中能够包含属性和方法（函数），方法（函数）不能孤立于对象单独存在。这样就产生了一个问题，有时候须要把一个方法（函数）做为参数传到另一个方法中的时候（好比回调功能），就须要建立一个包含这个方法的接口，传递的时候传递这个接口的实现类，通常是用匿名内部类的方式来。

以下面代码，首先建立一个Runnable的接口，在构造Thread时，建立一个Runnable的匿名内部类做为参数：

new Thread(new Runnable() {  
    public void run() {  
            System.out.println("hello");  
        }  
}).start();  


相似这种状况的还有swing中button等控件的监听器，以下面代码所示，建立该接口的一个匿名内部类实例做为参数传递到button的addActionListener方法中。

public interface ActionListener {   
    void actionPerformed(ActionEvent e);  
}  
  
button.addActionListener(new ActionListener() {   
  public void actionPerformed(ActionEvent e) {   
    ui.dazzle(e.getModifiers());  
  }  
});  

这样的代码的缺点是有代码笨重，可读性差，不能引用外面的非final的变量等。lambda表达式就是为了解决这类问题而诞生的。

在介绍Java8中的Lambda表达式以前，首先介绍一个概念叫“函数式接口”（functional interfaces）。对于任意一个Java接口，若是接口中只定义了惟一一个方法，那么这个接口就称之为“函数式接口”。好比JDK中的ActionListener、Runnable、Comparator等接口。

 

先来看一下Java8中的lambda表达式的使用示例，建立一个线程：

new Thread(() -> {System.out.println("hello");}).start();    

能够看到这段代码比上面建立线程的代码精简了不少，也有很好的可读性。

     () -> {System.out.println("hello");}  就是传说中的lambda表达式，等同于上面的new Runnable(), lambda大致分为3部分：

     1.最前面的部分是一对括号，里面是参数，这里无参数，就是一对空括号

     2.中间的是 -> ，用来分割参数和body部分

     3.是body部分，能够是一个表达式或者一个语句块。若是是一个表达式，表达式的值会被做为返回值返回；若是是语句块，须要用return语句指定返回值。

以下面这个lambda表达式接受一个整形的参数a，返回a的平方

(int a) -> a^2   

等同于

(int a) -> {return a^2;}  

更多的例子：

(int x, int y) -> x + y  
  
() -> 42  
  
(String s) -> { System.out.println(s); }  

建立一个FileFilter，文件过滤器：
FileFilter java = (File f) -> f.getName().endsWith(".java")  

建立一个线程：
new Thread(() -> {  
  //do sth here...  
}).start()  

建立一个Callable：
Callable<String> c = () -> "done";  

建立一个String的比较器：
Comparator<String> c = (s1, s2) -> s1.compareToIgnoreCase(s2);

并且lambda表达式能够赋值给一个变量：
Comparator<String> c;  
c = (String s1, String s2) -> s1.compareToIgnoreCase(s2);  

还能够做为方法的返回值：
public Runnable toDoLater() {  
  return () -> {  
    System.out.println("later");  
  };  
}  

从上面能够看到，一个lambda表达式被做为一个接口类型对待，具体对应哪一个接口，编译器会根据上下文环境推断出来，以下面的lambda表达式就表示一个ActionListener.

ActionListener l = (ActionEvent e) -> ui.dazzle(e.getModifiers());  

这有可能会形成一个表达式在不一样的上下文中被做为不一样的类型，以下面的这种状况，尽管两个表达式是相同的，上面的表达式被推断为Callable的类型，下面的会被推断为PrivilegedAction类型。

Callable<String> c = () -> "done";  
PrivilegedAction<String> a = () -> "done";  

那么编译器是根据哪些由于决定一个表达式的类型呢？

     若是一个表达式被推断为是T类型的，须要知足如下4个条件:

     1.T是函数式接口类型（只声明惟一一个方法）

     2.表达式和T中声明的方法的参数个数一致，参数类型也一致

     3.表达式和T中声明的方法的返回值类型一致

     4.表达式和T中声明的方法抛出的异常一致

有了这个准则，上面的疑问就迎刃而解了。（注：其实我以为没有必要纠结表达式的类型）

以上参考：http://www.iteye.com/topic/1127931

 

如下，继续学习：http://www.ruanyifeng.com/blog/2012/04/functional_programming.html

 

也许继"面向对象编程"以后，"函数式编程"会成为下一个编程的主流范式（paradigm）。

上面文章主要参考了Slava Akhmechet的"Functional Programming For The Rest of Us"。

 

"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。它属于"结构化编程"的一种，主要思想是把运算过程尽可能写成一系列嵌套的函数调用。举例来讲，如今有这样一个数学表达式：

(1 + 2) * 3 - 4


函数式编程要求使用函数，咱们能够把运算过程定义为不一样的函数，而后写成下面这样：
var result = subtract(multiply(add(1,2), 3), 4);

 

函数式编程具备五个鲜明的特色。

1. 函数是"第一等公民"

所谓"第一等公民"（first class），指的是函数与其余数据类型同样，处于平等地位，能够赋值给其余变量，也能够做为参数，传入另外一个函数，或者做为别的函数的返回值。

举例来讲，下面代码中的print变量就是一个函数，能够做为另外一个函数的参数。
　　var print = function(i){ console.log(i);};

　　[1,2,3].forEach(print);

 

2. 只用"表达式"，不用"语句"

"表达式"（expression）是一个单纯的运算过程，老是有返回值；"语句"（statement）是执行某种操做，没有返回值。函数式编程要求，只使用表达式，不使用语句。也就是说，每一步都是单纯的运算，并且都有返回值。

缘由是函数式编程的开发动机，一开始就是为了处理运算（computation），不考虑系统的读写（I/O）。"语句"属于对系统的读写操做，因此就被排斥在外。

固然，实际应用中，不作I/O是不可能的。所以，编程过程当中，函数式编程只要求把I/O限制到最小，不要有没必要要的读写行为，保持计算过程的单纯性。

 

3. 没有"反作用"

所谓"反作用"（side effect），指的是函数内部与外部互动（最典型的状况，就是修改全局变量的值），产生运算之外的其余结果。

函数式编程强调没有"反作用"，意味着函数要保持独立，全部功能就是返回一个新的值，没有其余行为，尤为是不得修改外部变量的值。

 

4. 不修改状态

上一点已经提到，函数式编程只是返回新的值，不修改系统变量。所以，不修改变量，也是它的一个重要特色。

在其余类型的语言中，变量每每用来保存"状态"（state）。不修改变量，意味着状态不能保存在变量中。函数式编程使用参数保存状态，最好的例子就是递归。下面的代码是一个将字符串逆序排列的函数，它演示了不一样的参数如何决定了运算所处的"状态"。

function reverse(string) {
　　　　if(string.length == 0) {
　　　　　　return string;
　　　　} else {
　　　　　　return reverse(string.substring(1, string.length)) + string.substring(0, 1);
　　　　}
　　}


因为使用了递归，函数式语言的运行速度比较慢，这是它长期不能在业界推广的主要缘由。

 

5. 引用透明

引用透明（Referential transparency），指的是函数的运行不依赖于外部变量或"状态"，只依赖于输入的参数，任什么时候候只要参数相同，引用函数所获得的返回值老是相同的。

有了前面的第三点和第四点，这点是很显然的。其余类型的语言，函数的返回值每每与系统状态有关，不一样的状态之下，返回值是不同的。这就叫"引用不透明"，很不利于观察和理解程序的行为。

 

3、意义

函数式编程到底有什么好处，为何会变得愈来愈流行？

 

1. 代码简洁，开发快速

函数式编程大量使用函数，减小了代码的重复，所以程序比较短，开发速度较快。

Paul Graham在《黑客与画家》一书中写道：一样功能的程序，极端状况下，Lisp代码的长度多是C代码的二十分之一。

若是某个新功能，Lisp语言完成开发须要三个月，C语言须要写五年。"固然，这样的对比故意夸大了差别，可是"在一个高度竞争的市场中，即便开发速度只相差两三倍，也足以使得你永远处在落后的位置。"

 

2. 接近天然语言，易于理解

 

3. 更方便的代码管理

函数式编程不依赖、也不会改变外界的状态，只要给定输入参数，返回的结果一定相同。所以，每个函数均可以被看作独立单元，颇有利于进行单元测试（unit testing）和除错（debugging），以及模块化组合。

 

4. 易于"并发编程"

函数式编程不须要考虑"死锁"（deadlock），由于它不修改变量，因此根本不存在"锁"线程的问题。没必要担忧一个线程的数据，被另外一个线程修改，因此能够很放心地把工做分摊到多个线程，部署"并发编程"（concurrency）。

多核CPU是未来的潮流，因此函数式编程的这个特性很是重要。

 

5. 代码的热升级

函数式编程没有反作用，只要保证接口不变，内部实现是外部无关的。因此，能够在运行状态下直接升级代码，不须要重启，也不须要停机。Erlang语言早就证实了这一点，它是瑞典爱立信公司为了管理电话系统而开发的，电话系统的升级固然是不能停机的。

 

（完）