淺談函數式編程

函數式編程（Functional Programming）是一種編程風格，它是相對於指令式編程風格而言的，常見的面向對象編程就是指令式編程風格。

指令式編程是面向計算機硬件的抽象，有變量（對應着存儲單元），賦值語句（獲取、存儲指令），表達式（內存引用和算術運算）和控制語句（跳轉語句）。

而函數式編程是面向數學的抽象，將計算描述為一種表達式求值。這里的函數實際就是數學中的函數，即自變量到因變量的映射。也就是說，一個函數的值僅決定於函數參數的值，不依賴其他狀態。

函數式編程是一種抽象程度很高的編程范式，純粹的函數式編程語言編寫的函數沒有變量，因此，任意一個函數，只要輸入是確定的，輸出就是確定的，這種純函數我們稱之為沒有副作用。而允許使用變量的程序設計語言，由於函數內部的變量狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數是有副作用的。

在函數式語言當中，函數作為一等公民，可以在任何地方定義，在函數內或函數外，可以作為函數的參數或返回值，可以對函數進行組合，也可以將函數賦值給變量。嚴格意義上的函數式編程意味着不適用可變的變量，賦值，循環和其他命令式控制結構進行編程。

函數式編程風格帶來的好處是：

1. 函數式編程使用不可變對象作為變量，不會修改變量的值，而是返回一個新的值，如此這樣，更容易理清頭緒，使得單元測試和調試更加容易；
2. 可以很自由地傳遞不可變對象，但對於可變對象來說，傳遞給其他代碼之前，需要先建造一個以防萬一的副本；
3. 一旦不可變對象完成構造以后，就不會有線程因為並發訪問而破壞對象內部狀態，因為根本沒有線程可以改變不可變對象的狀態；
4. 不可變對象讓哈希表鍵值更安全，所以哈希表鍵要求必須是不可變對象，否則使用可變對象，如果對象狀態發生變化，那么在哈希表中就找不到這個對象了；

具體到編程語言，Scala（靜態語言）和Python（動態語言）都能比較的支持函數式編程風格，但是它們都不是純函數式的，也就是說它們同時支持指令式風格和函數式風格。而Java基本是指令式風格，但自從Java8引入lambda表達式以后也開始部分支持函數式風格。函數式編程最典型的是諸如map, flatMap, reduce, filter等函數，它們的特點是支持某個函數作為上面這些函數的參數。

下面分別以Java、Scala和Python舉例函數式編程，其中Java對函數式編程只是間接的支持（通過函數式接口），支持度比較有限，而Scala和Python就對函數式編程支持的比較好。

Java函數式編程舉例：

package lxy.java.fp;

import java.util.*;
import java.util.function.*;


public class FPDemo {
    //定義泛型方法，用以根據第二個參數指定的條件從第一個參數指定的集合中過濾部分元素，並返回過濾后的結果。這里的第二個參數是一個函數式接口。
    public static <T> List <T> filter(List <T> list, Predicate <T> p) {
        List <T> results = new ArrayList <>();
        for (T s : list) {
            if (p.test(s)) {
                results.add(s);
            }
        }
        return results;
    }

    public static void main(String[] args) {
        List <String> myList = Arrays.asList("Hello", "Java", "Python", "Scala");

        //通過匿名類的方式
        List <String> results = filter(myList, new Predicate <String>() {
            public boolean test(String t) {
                return t.length() >= 5;
            }
        });
        System.out.println("through anonymous class:");
        System.out.println("strings with length more than 5:");
        for (String result : results) {
            System.out.println(result);
        }

        //行為參數化，通過匿名函數（即lambda表達式）方式，
        System.out.println("through lambda expression:");
        System.out.println("strings with length more than 5:");
        List <String> results2 = filter(myList, s -> s.length() >= 5);
        results2.forEach(s -> System.out.println(s));

        //很容易地將過濾條件由字符串長度大於等於5改為字符串以字母a結尾，
        // 這就是行為參數化，即將具體的邏輯（即行為或者函數）參數化，使得filter函數更加抽象，提高了代碼復用度
        //否則需要寫2個filter函數，一個過濾出長度大於等於5的字符串，另一個過濾出以字符a結尾的字符串
        System.out.println("strings ends with character 'a'");
        List <String> results3 = filter(myList, s -> s.endsWith("a"));
        results3.forEach(System.out::println);

        //Java流中的filter函數和map函數，注意這里的filter是Java庫函數，和前面自定義的filter函數不一樣
        System.out.println("strings with length more than 5 and its length:");
        myList.parallelStream().filter(s -> s.length() >= 5).map(s -> "(" + s + ", " + s.length() + ")")
                .forEach(System.out::println);

        //高階函數
        Function <Integer, Integer> f = (Integer x) -> x + 1;
        Function <Integer, Integer> g = (Integer x) -> x * x;
        Function <Integer, Integer> h = f.andThen(g);
        Function <Integer, Integer> r = f.compose(g);

        System.out.println("higher-order function:");
        System.out.println("h(2)=g(f(2))=" + h.apply(2));
        System.out.println("r(2)=f(g(2))=" + r.apply(2));

    }
}

 

Scala函數式編程舉例：

package lxy.scala.fp

object FPDemo {
    //定義泛型方法，用以根據第二個參數指定的條件從第一個參數指定的列表中過濾部分元素，並返回過濾后的結果，結果類型仍然是List。
    //這里的第二個參數是一個函數, 該函數輸入參數類型為T，返回值類型為Boolean
    def filter[T](list: List[T], f: T => Boolean) =
        for {e <- list if f(e) == true} yield e

    //高階函數，該函數定義為g(f(x))，其中函數f和g都是作為參數在調用該高階函數時指定的
    def highOrderFunction1(x: Int, f: Int => Int, g: Int => Int) = g(f(x))

    //定義嵌套函數，針對每個參數，外層函數都會返回一個函數，即內層函數
    //這里factor是自由變量，number是綁定變量。
    //閉包是一個函數，返回值依賴於聲明在函數外部的一個或多個變量
    //函數multiplier返回的函數就是閉包，factor就是外部的變量，也叫自由變量，number是綁定變量(形式參數）
    def multiplier(factor: Int): Int => Int = {
        def multiplyByFactor(number: Int) = factor * number

        return multiplyByFactor
    }

    //柯里化函數，類型是(Int)(Int) => Int
    def multiplier2(factor: Int)(number: Int) = factor * number

    //這個函數實際跟multiplier效果是一樣的，每傳入一個參數factor，都會返回一個函數
    //閉包是一個函數，返回值依賴於聲明在函數外部的一個或多個變量
    //函數multiplier3返回的函數就是閉包，factor就是外部的變量，也叫自由變量，number是綁定變量(形式參數）
    def multiplier3(factor: Int) = multiplier2(factor) _

    def main(args: Array[String]): Unit = {
        val myList = List("Hello", "Java", "Python", "Scala")
        println("strings with length more than 5")
        filter(myList, (s: String) => s.length >= 5).foreach(s => println(s))

        println("strings ends with character 'a'")
        filter(myList, (s: String) => s.endsWith("a")).foreach(println)

        println("strings with length more than 5 and its length:")
        //這里的filter不是自定義函數filter，而是庫函數，返回長度大於等於5的字符串以及對應的長度
        myList.filter(_.length >= 5).map(s => (s, s.length)).foreach(println)


        val result = highOrderFunction1(2, (x: Int) => x + 1, (x: Int) => x * x)
        println("f(x)=x+1, g(x)=x*x, g(f(2))=" + result)


        println("multiplier(2)=" + multiplier(2))
        println("multiplier(2)(3)=" + multiplier(2)(3))
        val double = multiplier(2)
        println("double(3)=" + double(3))

        println("multiplier3(3)=" + multiplier3(3))
        println("multiplier3(3)(4)=" + multiplier3(3)(4))
        val triple = multiplier3(3)
        println("triple(4)=" + triple(4))

    }
}

 

Python函數式編程舉例：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

if __name__ == "__main__":
    """
        Usage: ./fp_demo.py
    """

    # 定義函數filter，第一個參數是列表，第二個參數是函數
    def filter(list, f):
        return [e for e in list if f(e) == True]

    # python中沒有foreach函數，自己定義一個，其中第一個參數是函數，第二個參數是迭代器（列表）
    def foreach(f, iterator):
        for item in iterator:
            f(item)

    myList = ["Hello", "Java", "Python", "Scala"]
    resultList = filter(myList, lambda e: len(e) >= 5)
    print("strings with length more than 5", sep="\n")
    foreach(lambda e: print(e, sep="\n"), resultList)

    resultList2 = filter(myList, lambda e: e.endswith("a"))
    print("strings ends with character 'a'", sep="\n")
    foreach(lambda e: print(e, sep="\n"), resultList2)

    # 這里的map函數是python內置的
    print("strings with length more than 5 and its length:", sep="\n")
    foreach(lambda e: print(e, sep="\n"), map(lambda e: (e, len(e)), filter(myList, lambda e: len(e) >= 5)))

    # 高階函數，該函數定義為g(f(x))，其中函數f和g都是作為參數在調用該高階函數時指定的
    def highOrderFunction1(x, f, g):
        return g(f(x))

    # 該函數在下面對highOrderFunction1函數的調用中被當做參數傳入
    def f(x):
        return x + 1

    # 第二個參數傳入上面定義的f函數，作為第三個參數的的函數采用的是匿名函數
    result = highOrderFunction1(2, f, g=lambda x: x * x)
    print("f(x)=x+1, g(x)=x*x, g(f(2))=%d" % result, sep="\n")

    # 定義嵌套函數，針對每個參數，外層函數都會返回一個函數，即內層函數
    # 這里factor是自由變量，number是綁定變量。
    # 閉包是一個函數，返回值依賴於聲明在函數外部的一個或多個變量
    # 函數multiplier返回的函數就是閉包，factor就是外部的變量，也叫自由變量，number是綁定變量(形式參數）
    def multiplier(factor):
        def multiplyByFactor(number):
            return factor * number
        return multiplyByFactor


    print("multiplier(2)(3)=%s" % multiplier(2)(3))
    # double是一個函數，它將輸入參數乘以2倍以后返回
    double = multiplier(2)
    print("double(3)=%s" % double(3))

    print("multiplier(3)(4)=%s" % multiplier(3)(4))
    # triple是一個函數，它將輸入參數乘以3倍以后返回
    triple = multiplier(3)
    print("triple(4)=%s" % triple(4))

    # 第三個參數f是函數
    def add(x, y, f):
        return f(x) + f(y)

    print("2 ^ 2 + 3 ^2 = %s" % add(2, 3, lambda x: x * x))
    print("(2 + 1) + (3 + 1) = %s" % add(2, 3, f))

 

最后來看一個數學題目，已知a<=b, 且a和b都是整數，求下面三個公式的值。

 可以看到這三個公式分別是求a~b的和，a~b的平方和，a~b各自的階乘的和。可以看到三個公式是類似的，都是求和，只不過分別是對自身求和，對自身的平方求和以及對自身的階乘求和，也就是說這里有3個計算邏輯，需要對這3個計算邏輯計算出來的數求和。如果是指令式編程風格，就只能寫三個函數來解決問題。但是如果采用函數式編程風格，就可以只寫一個通用的求和函數來解決該問題，因為可以將這3個計算邏輯（函數）作為參數傳給之前的通用求和函數。下面分別用Java,Scala和Python來解決該問題。

Java代碼

package lxy.java.fp;

import java.util.function.*;


public class Sum4Integers {
    //通用求和函數，其中f是一個函數式接口，它接收一個整型參數並返回一個整型數值
    //采用遞歸計算方法
    private static int sum(Function<Integer, Integer> f, int a, int b) {
        if (a > b)
            return 0;
        else
            return f.apply(a) + sum(f, a + 1, b);
    }

    //求階乘函數,采用遞歸算法，較復雜，不能作為匿名函數傳入上面的通用求和參數，因此需要預先定義
    private static int factor(int x) {
        if (x == 0)
            return 1;
        else
            return x * factor(x - 1);
    }

    //求公式一函數，即求a~b的和
    //作為參數的函數就是返回變量自身，較簡單，采用匿名函數
    static int sumInts(int a, int b) {
        return sum(x -> x, a, b);
    }

    //求公式二函數，即求a^2 ~ b^2的和
    //作為參數的函數就是返回變量的平方，較簡單，采用匿名函數
    static int sumSquares(int a, int b) {
        return sum(x -> x * x, a, b);
    }

    //求公式三函數，即求a! ~ b!的和
    //作為參數的函數就是求變量的階乘，較復雜（本身是遞歸函數），采用定義好的函數factor
    static int sumFactors(int a, int b) {
        return sum(Sum4Integers::factor, a, b);
    }

    public static void main(String[] args) {
        System.out.println("1+2+3+4+5=" + sumInts(1, 5));
        System.out.println("1^2+2^2+3^2+4^2+5^2=" + sumSquares(1, 5));
        System.out.println("1!+2!+3!+4!+5!=" + sumFactors(1, 5));
    }

}

 

Scala代碼

package lxy.scala.fp


object Sum4Integers {
    //通用求和函數
    //采用遞歸計算方法
    private def sum(f: Int => Int, a: Int, b: Int): Int = if (a > b) 0 else f(a) + sum(f, a + 1, b)

    //求階乘函數,采用遞歸算法，較復雜，不能作為匿名函數傳入上面的通用求和參數，因此需要預先定義
    private def factor(x: Int): Int = if (x == 0) 1 else x * factor(x - 1)

    //求公式一函數，即求a~b的和
    //作為參數的函數就是返回變量自身，較簡單，采用匿名函數
    def sumInts(a: Int, b: Int) = sum(x => x, a, b)

    //求公式二函數，即求a^2 ~ b^2的和
    //作為參數的函數就是返回變量的平方，較簡單，采用匿名函數
    def sumSquares(a: Int, b: Int) = sum(x => x * x, a, b)

    //求公式三函數，即求a! ~ b!的和
    //作為參數的函數就是求變量的階乘，較復雜（本身是遞歸函數），采用定義好的函數factor
    def sumFactors(a: Int, b: Int) = sum(factor, a, b)

    def main(args: Array[String]): Unit = {
        println("1+2+3+4+5=" + sumInts(1, 5))
        println("1^2+2^2+3^2+4^2+5^2=" + sumSquares(1, 5))
        println("1!+2!+3!+4!+5!=" + sumFactors(1, 5))
    }

}

 

Python代碼

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

if __name__ == "__main__":
    """
        Usage: ./sum_integers.py
    """

    # 通用求和函數，采用遞歸計算方法
    def sum(f, a, b):
        if a > b:
            return 0
        else:
            return f(a) + sum(f, a + 1, b)

    # 求階乘函數,采用遞歸算法，較復雜，不能作為匿名函數傳入上面的通用求和參數，因此需要預先定義
    def factor(x):
        if x == 0:
            return 1
        else:
            return x * factor(x - 1)

    # 求公式一函數，即求a~b的和
    # 作為sum函數的第一個參數的函數就是返回變量自身，較簡單，采用匿名函數
    def sumInts(a, b):
        return sum(lambda x: x, a, b)

    # 求公式二函數，即求a^2 ~ b^2的和
    # 作為sum函數的第一個參數的函數就是返回變量的平方，較簡單，采用匿名函數
    def sumSquares(a, b):
        return sum(lambda x: x * x, a, b)

    # 求公式三函數，即求a! ~ b!的和
    # 作為sum函數的第一個參數的函數就是求變量的階乘，較復雜（本身是遞歸函數），采用定義好的函數factor
    def sumFactors(a, b):
        return sum(factor, a, b)

    print("1+2+3+4+5=%d" % sumInts(1, 5))
    print("1^2+2^2+3^2+4^2+5^2=%d" % sumSquares(1, 5))
    print("1!+2!+3!+4!+5!=%d" % sumFactors(1, 5))

 

從上面解決同一個問題的代碼量比較來看，Scala和Python比較短，而Java比較長，而且Java對函數式編程的支持目前還比較有限，因此函數式編程建議采用Scala或者Python。