花火

V1

2022/05/01阅读:32主题:全栈蓝

浅析函数式编程

函数式编程

1. 函数

高中一年级,应该是最早接触函数这个概念的时间,印象很深刻,毕竟是高考压轴大题,但它却是必修一第二章的内容。

我们来看一个必修一中最简单的一个函数:

上面的函数由三个部分组成:

  • x 自变量,由它决定初始值
  • f 它代表一个规则,用来对 自变量 进行计算。它也是用来描述函数关系的。
  • y 因变量,它用来标识通过函数计算以后的结果

一个函数的定义是:一个自变量 x ,经过一个规则 f(x) 的运算,得到一个因变量。其中的规则 f(x) 称为函数

上面的函数在数学上有一个术语叫一元函数

如上,它被称为二元函数,自变量的多少决定了这个函数的名称。

函数的概念,也被引入了计算机的领域中。很多的语言内置了函数的语法,帮助我们去实现类似于数学中函数的功能。

我们来看一个函数的定义

int main(int x) {
 return x + 1
}

这是 C 语言中定义一个函数的语法规则,可以看出它和数学中的函数完全一样,它传入了一个自变量 x 在计算机中,它叫参数,同时在函数内部,它对这个参数做了加法运算,并将其返回。此时这个加法运算就是数学中的规则 f(x) ,返回值就是因变量 y

类似,上面的函数叫一元函数,因为他只有一个参数。

同理,两个参数的,就称为二元函数,以此类推。

各种编程语言,提供了多种多样的函数的定义方式,但其本质和上面的函数完全一样,只是定义方式发生了变化而已。

  • Java
public static int method(int x) {
  return x + 1;
}
  • scala
def method(x: Int): Int = {
  x + 1
}
  • javascript
function method(x{
  return x + 1
}

2. 面向对象编程和函数式编程

写 OOP 的人都有一个体会,以类作为最小的调度单元,实现一个功能,需要去定义一些数据结构和操作这些数据结构的方法

也基于此,衍生出了设计模式这个代码复用的规则。设计模式的出现就是为了解决 OOP 带来的一些弊端,一定程度上实现对方法级别的重用。

函数式编程(后文以 FP 代替)讲究不变性,如同一个数学函数一样,只要你的入参相同,那么你的返回值必然相同,这样做的好处在于,这个函数对你的代码没有任何副作用,他不会更改所有的变量,只会返回一个新的变量,这也意味着它没有线程安全的问题。

了解过一些支持 FP 的同学,一定在相关的书籍上看到过一句话:函数是一等公民,支持 FP 的语言,将函数作为一种数据类型而存在。

而当函数成为一种数据类型的时候,很多我们经常使用到的设计模式也就有了其他的一些玩法。

3. 函数式编程下的设计模式

策略

策略设计模式,用来解决参数相同场景下的 if|else 的问题,直接看类图

  • Strategy(策略),定义所有支持的算法的公共接口。
  • ConcreteStrategy(具体策略,如 SimpleCompository , TeXCompositor)
  • Context (上下文,用来对具体的策略进行切换)

上面是典型的 OOP 的思路,我们来看一下 FP 下的代码实现

function test01(func{
  func("HelloWorld")
}

function test02(str{
  log.info(str)
}

test01(test02())

模版方法

模版方法,预留一些扩展(方法)留给子类自己实现,如生命周期函数。来看类图

FP函数式代码实现:

function test01(doCreateDocument, aboutToOpenDocument{
  log.info("start")
  doCreateDoCument(str)
  aboutToOpenDocument(str)
}

test01(data => {
  
}, error => {
  
})

可以发现无论是策略还是模版设计模式,都在使用函数作为数据类型,进而代替了 OOP 中的继承的作用。但对于一个函数而言,参数的个数问题成为了一个问题,实现一个功能我们可以依赖于外部的多个参数,此时一味的进行传参,对于后续代码维护、扩展都有很大的影响,于此函数式编程的一个特性也随之诞生。

4. 柯里化

闭包

闭包的概念来自于前端,通俗的话来讲,闭包就是引用了一个函数内部所有变量(包括参数)的一个组合。

闭包在函数创建的时候就会被默认创建,如同类的构造函数。

一个问题:没有返回值的函数存在闭包吗?

答:存在,没有使用而已

上面提到了一个多参数的问题,我们来看一段代码

function func1(str1{
  return func2(str2) {
    return str1 === str2
  }
}

const func3 = func1("1")
const ans = func3("2")

可以看到,func1 返回了一个函数 func2 ,func2 函数访问了 func1 函数的参数。这个的实现就依赖于 闭包

func3 获取到了 func2 的一个引用。此时继续调用 func3 ,得到 func1 最终的处理结果。

上面将函数调用分为了两部,如果连在一起写就是 func1("1")("2")

Func1(1)(2) 这样写的好处在哪里?

  • 将一个多元函数拆分为多个低元函数,参数之间可以进行预处理,然后进行整合;

  • 一元函数方便复用

这种变形调用方式,在函数式编程中存在一个术语柯里化

5. Java 中的函数式

从 1.8 开始 Jdk 从语言层面提供了一些能力用以在 Java 领域书写一些函数式编程。

函数作为参数

Java 1.8 以后提供了一个注解 @FunctionalInterface 。它的定义是:内部仅仅存在一个抽象方法的接口,即可声明为函数式接口。同时也提供了一些通用的类,来实现函数式编程。

图中最上面是四个基本的函数式接口,Consumer, Predicate, Supplier 三个类都是对 Function 类的一次封装,Consumer 类没有返回值,Predicate 返回值为 布尔值Supplier 类没有参数。而 Function 类是一个标准的函数式接口,看一下它的定义。

@FunctionalInterface
public interface Function<TR{

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */

    apply(T t);
  
   default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
   default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
  
}

可以看到,他内部提供了一个抽象函数, R apply(T t) 接受一个泛型,返回一个泛型。这是最标准的一元函数(只有一个参数)。

那么问题来了,如果我需要两个参数怎么办,JDK,提供了一个 BiFunction 可以接受两个参数,当然只能返回一个值,如果想返回多个值,请封装一个 集合类型。

那么问题又来了,如果我需要三个,或者更多的参数怎么办,不可能 JDK 将所有的参数个数的函数都封装一遍吧。

我们来思考一下这个问题的解决方法:对于多元(多参)的函数,我们能否将它们拆成一个个的一元函数,然后让这个一元函数返回一个一元函数,来实现多参数的传递。这就是我们前面提到的柯里化的思想。

来看一下具体的实现

public void test() {
        System.out.println(test01(param01 -> param02 -> param03 -> param01 + param02 + param03));
    }

    public String test01(Function<String, Function<String, Function<String, String>>> function) {
        // condition

        String method01 = "111";
        String method02 = "222";
        String method03 = "333";

        return function.apply(method01).apply(method02).apply(method03);
    }

通过以上的方式可以简单的去写一些服用代码,比如返回值相同但是调用方方不同的第三方调用。

以上就是对函数式编程的一个简单的介绍,具体的其他行为需要在真正的编码中进行实践。

分类:

后端

标签:

后端

作者介绍

花火
V1