学习如何使用 Java 8 中的流 API 和函数式编程结构。当 Java SE 8（又名核心 Java 8）在 2014 年被推出时，它引入了一些更改，从根本上影响了用它进行的编程。这些更改中有两个紧密相连的部分：流 API 和函数式编程构造。本文使用代码示例，从基础到高级特性，介绍每个部分并说明它们之间的相互作用。基础特性流 API 是在数据序列中迭代元素的简洁而高级的方法。包 java.util.stream 和 java.util.function 包含了用于流 API 和相关函数式编程构造的新库。当然，代码示例胜过千言万语。下面的代码段用大约 2,000 个随机整数值填充了一个 List：Random rand = new Random2(); List<Integer> list = new ArrayList<Integer>(); // 空 list for (int i = 0; i < 2048; i++) list.add(rand.nextInt()); // 填充它另外用一个 for 循环可用于遍历填充列表，以将偶数值收集到另一个列表中。流 API 提供了一种更简洁的方法来执行此操作：List <Integer> evens = list .stream() // 流化 list .filter(n -> (n & 0x1) == 0) // 过滤出奇数值 .collect(Collectors.toList()); // 收集偶数值这个例子有三个来自流 API 的函数：stream 函数可以将集合转换为流，而流是一个每次可访问一个值的传送带。流化是惰性的（因此也是高效的），因为值是根据需要产生的，而不是一次性产生的。filter 函数确定哪些流的值（如果有的话）通过了处理管道中的下一个阶段，即 collect 阶段。filter 函数是 高阶的 higher-order ，因为它的参数是一个函数 —— 在这个例子中是一个 lambda 表达式，它是一个未命名的函数，并且是 Java 新的函数式编程结构的核心。lambda 语法与传统的 Java 完全不同：n -> (n & 0x1) == 0箭头（一个减号后面紧跟着一个大于号）将左边的参数列表与右边的函数体分隔开。参数 n 虽未明确类型，但也可以明确。在任何情况下，编译器都会发现 n 是个 Integer。如果有多个参数，这些参数将被括在括号中，并用逗号分隔。在本例中，函数体检查一个整数的最低位（最右）是否为零，这用来表示偶数。过滤器应返回一个布尔值。尽管可以，但该函数的主体中没有显式的 return。如果主体没有显式的 return，则主体的最后一个表达式即是返回值。在这个例子中，主体按照 lambda 编程的思想编写，由一个简单的布尔表达式 (n & 0x1) == 0 组成。collect 函数将偶数值收集到引用为 evens 的列表中。如下例所示，collect 函数是线程安全的，因此，即使在多个线程之间共享了过滤操作，该函数也可以正常工作。方便的功能和轻松实现多线程在生产环境中，数据流的源可能是文件或网络连接。为了学习流 API, Java 提供了诸如 IntStream 这样的类型，它可以用各种类型的元素生成流。这里有一个 IntStream 的例子：IntStream // 整型流 .range(1, 2048) // 生成此范围内的整型流 .parallel() // 为多个线程分区数据 .filter(i -> ((i & 0x1) > 0)) // 奇偶校验 - 只允许奇数通过 .forEach(System.out::println); // 打印每个值IntStream 类型包括一个 range 函数，该函数在指定的范围内生成一个整数值流，在本例中，以 1 为增量，从 1 递增到 2048。parallel 函数自动划分该工作到多个线程中，在各个线程中进行过滤和打印。（线程数通常与主机系统上的 CPU 数量匹配。）函数 forEach 参数是一个方法引用，在本例中是对封装在 System.out 中的 println 方法的引用，方法输出类型为 PrintStream。方法和构造器引用的语法将在稍后讨论。由于具有多线程，因此整数值整体上以任意顺序打印，但在给定线程中是按顺序打印的。例如，如果线程 T1 打印 409 和 411，那么 T1 将按照顺序 409-411 打印，但是其它某个线程可能会预先打印 2045。parallel 调用后面的线程是并发执行的，因此它们的输出顺序是不确定的。map/reduce 模式map/reduce 模式在处理大型数据集方面变得很流行。一个 map/reduce 宏操作由两个微操作构成。首先，将数据分散（ 映射 mapped ）到各个工作程序中，然后将单独的结果收集在一起 —— 也可能收集统计起来成为一个值，即 归约 reduction 。归约可以采用不同的形式，如以下示例所示。下面 Number 类的实例用 EVEN 或 ODD 表示有奇偶校验的整数值：public class Number { enum Parity { EVEN, ODD } private int value; public Number(int n) { setValue(n); } public void setValue(int value) { this.value = value; } public int getValue() { return this.value; } public Parity getParity() { return ((value & 0x1) == 0) ? Parity.EVEN : Parity.ODD; } public void dump() { System.out.format("Value: %2d (parity: %s)\n", getValue(), (getParity() == Parity.ODD ? "odd" : "even")); } }下面的代码演示了用 Number 流进行 map/reduce 的情形，从而表明流 API 不仅可以处理 int 和 float 等基本类型，还可以处理程序员自定义的类类型。在下面的代码段中，使用了 parallelStream 而不是 stream 函数对随机整数值列表进行流化处理。与前面介绍的 parallel 函数一样，parallelStream 变体也可以自动执行多线程。final int howMany = 200; Random r = new Random(); Number[] nums = new Number[howMany]; for (int i = 0; i < howMany; i++) nums[i] = new Number(r.nextInt(100)); List<Number> listOfNums = Arrays.asList(nums); // 将数组转化为 list Integer sum4All = listOfNums .parallelStream() // 自动执行多线程 .mapToInt(Number::getValue) // 使用方法引用，而不是 lambda .sum(); // 将流值计算出和值 System.out.println("The sum of the randomly generated values is: " + sum4All);高阶的 mapToInt 函数可以接受一个 lambda 作为参数，但在本例中，它接受一个方法引用，即 Number::getValue。getValue 方法不需要参数，它返回给定的 Number 实例的 int 值。语法并不复杂：类名 Number 后跟一个双冒号和方法名。回想一下先前的例子 System.out::println，它在 System 类中的 static 属性 out 后面有一个双冒号。方法引用 Number::getValue 可以用下面的 lambda 表达式替换。参数 n 是流中的 Number 实例中的之一：mapToInt(n -> n.getValue())通常，lambda 表达式和方法引用是可互换的：如果像 mapToInt 这样的高阶函数可以采用一种形式作为参数，那么这个函数也可以采用另一种形式。这两个函数式编程结构具有相同的目的 —— 对作为参数传入的数据执行一些自定义操作。在两者之间进行选择通常是为了方便。例如，lambda 可以在没有封装类的情况下编写，而方法则不能。我的习惯是使用 lambda，除非已经有了适当的封装方法。当前示例末尾的 sum 函数通过结合来自 parallelStream 线程的部分和，以线程安全的方式进行归约。但是，程序员有责任确保在 parallelStream 调用引发的多线程过程中，程序员自己的函数调用（在本例中为 getValue）是线程安全的。最后一点值得强调。lambda 语法鼓励编写 纯函数 pure function ，即函数的返回值仅取决于传入的参数（如果有）；纯函数没有副作用，例如更新一个类中的 static 字段。因此，纯函数是线程安全的，并且如果传递给高阶函数的函数参数（例如 filter 和 map ）是纯函数，则流 API 效果最佳。对于更细粒度的控制，有另一个流 API 函数，名为 reduce，可用于对 Number 流中的值求和:Integer sum4AllHarder = listOfNums .parallelStream() // 多线程 .map(Number::getValue) // 每个 Number 的值 .reduce(0, (sofar, next) -> sofar + next); // 求和此版本的 reduce 函数带有两个参数，第二个参数是一个函数：第一个参数（在这种情况下为零）是特征值，该值用作求和操作的初始值，并且在求和过程中流结束时用作默认值。第二个参数是累加器，在本例中，这个 lambda 表达式有两个参数：第一个参数（sofar）是正在运行的和，第二个参数（next）是来自流的下一个值。运行的和以及下一个值相加，然后更新累加器。请记住，由于开始时调用了 parallelStream，因此 map 和 reduce 函数现在都在多线程上下文中执行。在到目前为止的示例中，流值被收集，然后被规约，但是，通常情况下，流 API 中的 Collectors 可以累积值，而不需要将它们规约到单个值。正如下一个代码段所示，收集活动可以生成任意丰富的数据结构。该示例使用与前面示例相同的 listOfNums：Map<Number.Parity, List<Number>> numMap = listOfNums .parallelStream() .collect(Collectors.groupingBy(Number::getParity)); List<Number> evens = numMap.get(Number.Parity.EVEN); List<Number> odds = numMap.get(Number.Parity.ODD);第一行中的 numMap 指的是一个 Map，它的键是一个 Number 奇偶校验位（ODD 或 EVEN），其值是一个具有指定奇偶校验位值的 Number 实例的 List。同样，通过 parallelStream 调用进行多线程处理，然后 collect 调用（以线程安全的方式）将部分结果组装到 numMap 引用的 Map 中。然后，在 numMap 上调用 get 方法两次，一次获取 evens，第二次获取 odds。实用函数 dumpList 再次使用来自流 API 的高阶 forEach 函数：private void dumpList(String msg, List<Number> list) { System.out.println("\n" + msg); list.stream().forEach(n -> n.dump()); // 或者使用 forEach(Number::dump) }这是示例运行中程序输出的一部分：The sum of the randomly generated values is: 3322 The sum again, using a different method: 3322 Evens: Value: 72 (parity: even) Value: 54 (parity: even) ... Value: 92 (parity: even) Odds: Value: 35 (parity: odd) Value: 37 (parity: odd) ... Value: 41 (parity: odd)用于代码简化的函数式结构函数式结构（如方法引用和 lambda 表达式）非常适合在流 API 中使用。这些构造代表了 Java 中对高阶函数的主要简化。即使在糟糕的过去，Java 也通过 Method 和 Constructor 类型在技术上支持高阶函数，这些类型的实例可以作为参数传递给其它函数。由于其复杂性，这些类型在生产级 Java 中很少使用。例如，调用 Method 需要对象引用（如果方法是非静态的）或至少一个类标识符（如果方法是静态的）。然后，被调用的 Method 的参数作为对象实例传递给它，如果没有发生多态（那会出现另一种复杂性！），则可能需要显式向下转换。相比之下，lambda 和方法引用很容易作为参数传递给其它函数。但是，新的函数式结构在流 API 之外具有其它用途。考虑一个 Java GUI 程序，该程序带有一个供用户按下的按钮，例如，按下以获取当前时间。按钮按下的事件处理程序可能编写如下：JButton updateCurrentTime = new JButton("Update current time"); updateCurrentTime.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { currentTime.setText(new Date().toString()); } });这个简短的代码段很难解释。关注第二行，其中方法 addActionListener 的参数开始如下：new ActionListener() {这似乎是错误的，因为 ActionListener 是一个抽象接口，而抽象类型不能通过调用 new 实例化。但是，事实证明，还有其它一些实例被实例化了：一个实现此接口的未命名内部类。如果上面的代码封装在名为 OldJava 的类中，则该未命名的内部类将被编译为 OldJava$1.class。actionPerformed 方法在这个未命名的内部类中被重写。现在考虑使用新的函数式结构进行这个令人耳目一新的更改：updateCurrentTime.addActionListener(e -> currentTime.setText(new Date().toString()));lambda 表达式中的参数 e 是一个 ActionEvent 实例，而 lambda 的主体是对按钮上的 setText 的简单调用。函数式接口和函数组合到目前为止，使用的 lambda 已经写好了。但是，为了方便起见，我们可以像引用封装方法一样引用 lambda 表达式。以下一系列简短示例说明了这一点。考虑以下接口定义：@FunctionalInterface // 可选，通常省略 interface BinaryIntOp { abstract int compute(int arg1, int arg2); // abstract 声明可以被删除 }注释 @FunctionalInterface 适用于声明唯一抽象方法的任何接口；在本例中，这个抽象接口是 compute。一些标准接口，（例如具有唯一声明方法 run 的 Runnable 接口）同样符合这个要求。在此示例中，compute 是已声明的方法。该接口可用作引用声明中的目标类型：BinaryIntOp div = (arg1, arg2) -> arg1 / arg2; div.compute(12, 3); // 4包 java.util.function 提供各种函数式接口。以下是一些示例。下面的代码段介绍了参数化的 Predicate 函数式接口。在此示例中，带有参数 String 的 Predicate<String> 类型可以引用具有 String 参数的 lambda 表达式或诸如 isEmpty 之类的 String 方法。通常情况下，Predicate 是一个返回布尔值的函数。Predicate<String> pred = String::isEmpty; // String 方法的 predicate 声明 String[] strings = {"one", "two", "", "three", "four"}; Arrays.asList(strings) .stream() .filter(pred) // 过滤掉非空字符串 .forEach(System.out::println); // 只打印空字符串在字符串长度为零的情况下，isEmpty Predicate 判定结果为 true。 因此，只有空字符串才能进入管道的 forEach 阶段。下一段代码将演示如何将简单的 lambda 或方法引用组合成更丰富的 lambda 或方法引用。考虑这一系列对 IntUnaryOperator 类型的引用的赋值，它接受一个整型参数并返回一个整型值：IntUnaryOperator doubled = n -> n * 2; IntUnaryOperator tripled = n -> n * 3; IntUnaryOperator squared = n -> n * n;IntUnaryOperator 是一个 FunctionalInterface，其唯一声明的方法为 applyAsInt。现在可以单独使用或以各种组合形式使用这三个引用 doubled、tripled 和 squared：int arg = 5; doubled.applyAsInt(arg); // 10 tripled.applyAsInt(arg); // 15 squared.applyAsInt(arg); // 25以下是一些函数组合的样例：int arg = 5; doubled.compose(squared).applyAsInt(arg); // 5 求 2 次方后乘 2：50 tripled.compose(doubled).applyAsInt(arg); // 5 乘 2 后再乘 3：30 doubled.andThen(squared).applyAsInt(arg); // 5 乘 2 后求 2 次方：100 squared.andThen(tripled).applyAsInt(arg); // 5 求 2 次方后乘 3：75函数组合可以直接使用 lambda 表达式实现，但是引用使代码更简洁。构造器引用构造器引用是另一种函数式编程构造，而这些引用在比 lambda 和方法引用更微妙的上下文中非常有用。再一次重申，代码示例似乎是最好的解释方式。考虑这个 POJO 类：public class BedRocker { // 基岩的居民 private String name; public BedRocker(String name) { this.name = name; } public String getName() { return this.name; } public void dump() { System.out.println(getName()); } }该类只有一个构造函数，它需要一个 String 参数。给定一个名字数组，目标是生成一个 BedRocker 元素数组，每个名字代表一个元素。下面是使用了函数式结构的代码段：String[] names = {"Fred", "Wilma", "Peebles", "Dino", "Baby Puss"}; Stream<BedRocker> bedrockers = Arrays.asList(names).stream().map(BedRocker::new); BedRocker[] arrayBR = bedrockers.toArray(BedRocker[]::new); Arrays.asList(arrayBR).stream().forEach(BedRocker::dump);在较高的层次上，这个代码段将名字转换为 BedRocker 数组元素。具体来说，代码如下所示。Stream 接口（在包 java.util.stream 中）可以被参数化，而在本例中，生成了一个名为 bedrockers 的 BedRocker 流。Arrays.asList 实用程序再次用于流化一个数组 names，然后将流的每一项传递给 map 函数，该函数的参数现在是构造器引用 BedRocker::new。这个构造器引用通过在每次调用时生成和初始化一个 BedRocker 实例来充当一个对象工厂。在第二行执行之后，名为 bedrockers 的流由五项 BedRocker 组成。这个例子可以通过关注高阶 map 函数来进一步阐明。在通常情况下，一个映射将一个类型的值（例如，一个 int）转换为另一个相同类型的值（例如，一个整数的后继）:map(n -> n + 1) // 将 n 映射到其后继然而，在 BedRocker 这个例子中，转换更加戏剧化，因为一个类型的值（代表一个名字的 String）被映射到一个不同类型的值，在这个例子中，就是一个 BedRocker 实例，这个字符串就是它的名字。转换是通过一个构造器调用来完成的，它是由构造器引用来实现的：map(BedRocker::new) // 将 String 映射到 BedRocker传递给构造器的值是 names 数组中的其中一项。此代码示例的第二行还演示了一个你目前已经非常熟悉的转换：先将数组先转换成 List，然后再转换成 Stream：Stream<BedRocker> bedrockers = Arrays.asList(names).stream().map(BedRocker::new);第三行则是另一种方式 —— 流 bedrockers 通过使用数组构造器引用 BedRocker[]::new 调用 toArray 方法:BedRocker[ ] arrayBR = bedrockers.toArray(BedRocker[]::new);该构造器引用不会创建单个 BedRocker 实例，而是创建这些实例的整个数组：该构造器引用现在为 BedRocker[]:new，而不是 BedRocker::new。为了进行确认，将 arrayBR 转换为 List，再次对其进行流式处理，以便可以使用 forEach 来打印 BedRocker 的名字。Fred Wilma Peebles Dino Baby Puss该示例对数据结构的微妙转换仅用几行代码即可完成，从而突出了可以将 lambda，方法引用或构造器引用作为参数的各种高阶函数的功能。 柯里化 Currying 柯里化函数是指减少函数执行任何工作所需的显式参数的数量（通常减少到一个）。（该术语是为了纪念逻辑学家 Haskell Curry。）一般来说，函数的参数越少，调用起来就越容易，也更健壮。（回想一下一些需要半打左右参数的噩梦般的函数！）因此，应将柯里化视为简化函数调用的一种尝试。java.util.function 包中的接口类型适合于柯里化，如以下示例所示。引用的 IntBinaryOperator 接口类型是为函数接受两个整型参数，并返回一个整型值：IntBinaryOperator mult2 = (n1, n2) -> n1 * n2; mult2.applyAsInt(10, 20); // 200 mult2.applyAsInt(10, 30); // 300引用 mult2 强调了需要两个显式参数，在本例中是 10 和 20。前面介绍的 IntUnaryOperator 比 IntBinaryOperator 简单，因为前者只需要一个参数，而后者则需要两个参数。两者均返回整数值。因此，目标是将名为 mult2 的两个参数 IntBinraryOperator 柯里化成一个单一的 IntUnaryOperator 版本 curriedMult2。考虑 IntFunction<R> 类型。此类型的函数采用整型参数，并返回类型为 R 的结果，该结果可以是另一个函数 —— 更准确地说，是 IntBinaryOperator。让一个 lambda 返回另一个 lambda 很简单：arg1 -> (arg2 -> arg1 * arg2) // 括号可以省略完整的 lambda 以 arg1 开头，而该 lambda 的主体以及返回的值是另一个以 arg2 开头的 lambda。返回的 lambda 仅接受一个参数（arg2），但返回了两个数字的乘积（arg1 和 arg2）。下面的概述，再加上代码，应该可以更好地进行说明。以下是如何柯里化 mult2 的概述：类型为 IntFunction<IntUnaryOperator> 的 lambda 被写入并调用，其整型值为 10。返回的 IntUnaryOperator 缓存了值 10，因此变成了已柯里化版本的 mult2，在本例中为 curriedMult2。然后使用单个显式参数（例如，20）调用 curriedMult2 函数，该参数与缓存的参数（在本例中为 10）相乘以生成返回的乘积。。这是代码的详细信息：// 创建一个接受一个参数 n1 并返回一个单参数 n2 -> n1 * n2 的函数，该函数返回一个（n1 * n2 乘积的）整型数。 IntFunction<IntUnaryOperator> curriedMult2Maker = n1 -> (n2 -> n1 * n2);调用 curriedMult2Maker 生成所需的 IntUnaryOperator 函数：// 使用 curriedMult2Maker 获取已柯里化版本的 mult2。 // 参数 10 是上面的 lambda 的 n1。 IntUnaryOperator curriedMult2 = curriedMult2Maker2.apply(10);值 10 现在缓存在 curriedMult2 函数中，以便 curriedMult2 调用中的显式整型参数乘以 10：curriedMult2.applyAsInt(20); // 200 = 10 * 20 curriedMult2.applyAsInt(80); // 800 = 10 * 80缓存的值可以随意更改：curriedMult2 = curriedMult2Maker.apply(50); // 缓存 50 curriedMult2.applyAsInt(101); // 5050 = 101 * 50当然，可以通过这种方式创建多个已柯里化版本的 mult2，每个版本都有一个 IntUnaryOperator。柯里化充分利用了 lambda 的强大功能：可以很容易地编写 lambda 表达式来返回需要的任何类型的值，包括另一个 lambda。总结Java 仍然是基于类的面向对象的编程语言。但是，借助流 API 及其支持的函数式构造，Java 向函数式语言（例如 Lisp）迈出了决定性的（同时也是受欢迎的）一步。结果是 Java 更适合处理现代编程中常见的海量数据流。在函数式方向上的这一步还使以在前面的代码示例中突出显示的管道的方式编写清晰简洁的 Java 代码更加容易：dataStream .parallelStream() // 多线程以提高效率 .filter(...) // 阶段 1 .map(...) // 阶段 2 .filter(...) // 阶段 3 ... .collect(...); // 或者，也可以进行归约：阶段 N自动多线程，以 parallel 和 parallelStream 调用为例，建立在 Java 的 fork/join 框架上，该框架支持 任务窃取 task stealing 以提高效率。假设 parallelStream 调用后面的线程池由八个线程组成，并且 dataStream 被八种方式分区。某个线程（例如，T1）可能比另一个线程（例如，T7）工作更快，这意味着应该将 T7 的某些任务移到 T1 的工作队列中。这会在运行时自动发生。在这个简单的多线程世界中，程序员的主要职责是编写线程安全函数，这些函数作为参数传递给在流 API 中占主导地位的高阶函数。尤其是 lambda 鼓励编写纯函数（因此是线程安全的）函数。via: https://opensource.com/article/20/1/javastream作者：Marty Kalin 选题：lujun9972 译者：laingke 校对：wxy本文由 LCTT 原创编译，Linux中国 荣誉推出
toolz 库允许你操作函数，使其更容易理解，更容易测试代码。在这个由两部分组成的系列文章的第二部分中，我们将继续探索如何将函数式编程方法中的好想法引入到 Python中，以实现两全其美。在上一篇文章中，我们介绍了不可变数据结构。 这些数据结构使得我们可以编写“纯”函数，或者说是没有副作用的函数，仅仅接受一些参数并返回结果，同时保持良好的性能。在这篇文章中，我们使用 toolz 库来构建。 这个库具有操作此类函数的函数，并且它们在纯函数中表现得特别好。 在函数式编程世界中，它们通常被称为“高阶函数”，因为它们将函数作为参数，将函数作为结果返回。让我们从这里开始：def add_one_word(words, word): return words.set(words.get(word, 0) + 1)这个函数假设它的第一个参数是一个不可变的类似字典的对象，它返回一个新的类似字典的在相关位置递增的对象：这就是一个简单的频率计数器。但是，只有将它应用于单词流并做归纳时才有用。 我们可以使用内置模块 functools 中的归纳器。functools.reduce(function, stream, initializer)我们想要一个函数，应用于流，并且能能返回频率计数。我们首先使用 toolz.curry 函数：add_all_words = curry(functools.reduce, add_one_word)使用此版本，我们需要提供初始化程序。但是，我们不能只将 pyrsistent.m 函数添加到 curry 函数中； 因为这个顺序是错误的。add_all_words_flipped = flip(add_all_words)flip 这个高阶函数返回一个调用原始函数的函数，并且翻转参数顺序。get_all_words = add_all_words_flipped(pyrsistent.m())我们利用 flip 自动调整其参数的特性给它一个初始值：一个空字典。现在我们可以执行 get_all_words(word_stream) 这个函数来获取频率字典。 但是，我们如何获得一个单词流呢？ Python 文件是按行供流的。def to_words(lines): for line in lines: yield from line.split()在单独测试每个函数后，我们可以将它们组合在一起：words_from_file = toolz.compose(get_all_words, to_words)在这种情况下，组合只是使两个函数很容易阅读：首先将文件的行流应用于 to_words，然后将 get_all_words 应用于 to_words 的结果。 但是文字上读起来似乎与代码执行相反。当我们开始认真对待可组合性时，这很重要。有时可以将代码编写为一个单元序列，单独测试每个单元，最后将它们全部组合。如果有几个组合元素时，组合的顺序可能就很难理解。toolz 库借用了 Unix 命令行的做法，并使用 pipe 作为执行相同操作的函数，但顺序相反。words_from_file = toolz.pipe(to_words, get_all_words)现在读起来更直观了：将输入传递到 to_words，并将结果传递给 get_all_words。 在命令行上，等效写法如下所示：$ cat files | to_words | get_all_wordstoolz 库允许我们操作函数，切片、分割和组合，以使我们的代码更容易理解和测试。via: https://opensource.com/article/18/10/functional-programming-python-toolz作者：Moshe Zadka 选题：lujun9972 译者：Flowsnow 校对：wxy本文由 LCTT 原创编译，Linux中国 荣誉推出
不可变性可以帮助我们更好地理解我们的代码。下面我将讲述如何在不牺牲性能的条件下来实现它。在这个由两篇文章构成的系列中，我将讨论如何将函数式编程方法论中的思想引入至 Python 中，来充分发挥这两个领域的优势。本文（也就是第一篇文章）中，我们将探讨不可变数据结构的优势。第二部分会探讨如何在 toolz 库的帮助下，用 Python 实现高层次的函数式编程理念。为什么要用函数式编程？因为变化的东西更难推理。如果你已经确信变化会带来麻烦，那很棒。如果你还没有被说服，在文章结束时，你会明白这一点的。我们从思考正方形和矩形开始。如果我们抛开实现细节，单从接口的角度考虑，正方形是矩形的子类吗？子类的定义基于里氏替换原则。一个子类必须能够完成超类所做的一切。如何为矩形定义接口？from zope.interface import Interface class IRectangle(Interface): def get_length(self): """正方形能做到""" def get_width(self): """正方形能做到""" def set_dimensions(self, length, width): """啊哦"""如果我们这么定义，那正方形就不能成为矩形的子类：如果长度和宽度不等，它就无法对 set_dimensions 方法做出响应。另一种方法，是选择将矩形做成不可变对象。class IRectangle(Interface): def get_length(self): """正方形能做到""" def get_width(self): """正方形能做到""" def with_dimensions(self, length, width): """返回一个新矩形"""现在，我们可以将正方形视为矩形了。在调用 with_dimensions 时，它可以返回一个新的矩形（它不一定是个正方形），但它本身并没有变，依然是一个正方形。这似乎像是个学术问题 —— 直到我们认为正方形和矩形可以在某种意义上看做一个容器的侧面。在理解了这个例子以后，我们会处理更传统的容器，以解决更现实的案例。比如，考虑一下随机存取数组。我们现在有 ISquare 和 IRectangle，而且 ISequere 是 IRectangle 的子类。我们希望把矩形放进随机存取数组中：class IArrayOfRectangles(Interface): def get_element(self, i): """返回一个矩形""" def set_element(self, i, rectangle): """'rectangle' 可以是任意 IRectangle 对象"""我们同样希望把正方形放进随机存取数组：class IArrayOfSquare(Interface): def get_element(self, i): """返回一个正方形""" def set_element(self, i, square): """'square' 可以是任意 ISquare 对象"""尽管 ISquare 是 IRectangle 的子集，但没有任何一个数组可以同时实现 IArrayOfSquare 和 IArrayOfRectangle.为什么不能呢？假设 bucket 实现了这两个类的功能。>>> rectangle = make_rectangle(3, 4) >>> bucket.set_element(0, rectangle) # 这是 IArrayOfRectangle 中的合法操作 >>> thing = bucket.get_element(0) # IArrayOfSquare 要求 thing 必须是一个正方形 >>> assert thing.height == thing.width Traceback (most recent call last): File "<stdin>", line 1, in <module> AssertionError无法同时实现这两类功能，意味着这两个类无法构成继承关系，即使 ISquare 是 IRectangle 的子类。问题来自 set_element 方法：如果我们实现一个只读的数组，那 IArrayOfSquare 就可以是 IArrayOfRectangle 的子类了。在可变的 IRectangle 和可变的 IArrayOf* 接口中，可变性都会使得对类型和子类的思考变得更加困难 —— 放弃变换的能力，意味着我们的直觉所希望的类型间关系能够成立了。可变性还会带来作用域方面的影响。当一个共享对象被两个地方的代码改变时，这种问题就会发生。一个经典的例子是两个线程同时改变一个共享变量。不过在单线程程序中，即使在两个相距很远的地方共享一个变量，也是一件简单的事情。从 Python 语言的角度来思考，大多数对象都可以从很多位置来访问：比如在模块全局变量，或在一个堆栈跟踪中，或者以类属性来访问。如果我们无法对共享做出约束，那我们可能要考虑对可变性来进行约束了。这是一个不可变的矩形，它利用了 attr 库：@attr.s(frozen=True) class Rectange(object): length = attr.ib() width = attr.ib() @classmethod def with_dimensions(cls, length, width): return cls(length, width)这是一个正方形：@attr.s(frozen=True) class Square(object): side = attr.ib() @classmethod def with_dimensions(cls, length, width): return Rectangle(length, width)使用 frozen 参数，我们可以轻易地使 attrs 创建的类成为不可变类型。正确实现 __setitem__ 方法的工作都交给别人完成了，对我们是不可见的。修改对象仍然很容易；但是我们不可能改变它的本质。too_long = Rectangle(100, 4) reasonable = attr.evolve(too_long, length=10)Pyrsistent 能让我们拥有不可变的容器。# 由整数构成的向量 a = pyrsistent.v(1, 2, 3) # 并非由整数构成的向量 b = a.set(1, "hello")尽管 b 不是一个由整数构成的向量，但没有什么能够改变 a 只由整数构成的性质。如果 a 有一百万个元素呢？b 会将其中的 999999 个元素复制一遍吗？Pyrsistent 具有“大 O”性能保证：所有操作的时间复杂度都是 O(log n). 它还带有一个可选的 C 语言扩展，以在“大 O”性能之上进行提升。修改嵌套对象时，会涉及到“变换器”的概念：blog = pyrsistent.m( title="My blog", links=pyrsistent.v("github", "twitter"), posts=pyrsistent.v( pyrsistent.m(title="no updates", content="I'm busy"), pyrsistent.m(title="still no updates", content="still busy"))) new_blog = blog.transform(["posts", 1, "content"], "pretty busy")new_blog 现在将是如下对象的不可变等价物：{'links': ['github', 'twitter'], 'posts': [{'content': "I'm busy", 'title': 'no updates'}, {'content': 'pretty busy', 'title': 'still no updates'}], 'title': 'My blog'}不过 blog 依然不变。这意味着任何拥有旧对象引用的人都没有受到影响：转换只会有局部效果。当共享行为猖獗时，这会很有用。例如，函数的默认参数：def silly_sum(a, b, extra=v(1, 2)): extra = extra.extend([a, b]) return sum(extra)在本文中，我们了解了为什么不可变性有助于我们来思考我们的代码，以及如何在不带来过大性能负担的条件下实现它。下一篇，我们将学习如何借助不可变对象来实现强大的程序结构。via: https://opensource.com/article/18/10/functional-programming-python-immutable-data-structures作者：Moshe Zadka 选题：lujun9972 译者：StdioA 校对：wxy本文由 LCTT 原创编译，Linux中国 荣誉推出
探索函数式编程，通过它让你的程序更具有可读性和易于调试当 Brendan Eich 在 1995 年创造 JavaScript 时，他原本打算将 Scheme 移植到浏览器里 。Scheme 作为 Lisp 的方言，是一种函数式编程语言。而当 Eich 被告知新的语言应该是一种可以与 Java 相比的脚本语言后，他最终确立了一种拥有 C 风格语法的语言（也和 Java 一样），但将函数视作一等公民。而 Java 直到版本 8 才从技术上将函数视为一等公民，虽然你可以用匿名类来模拟它。这个特性允许 JavaScript 通过函数式范式编程。JavaScript 是一个多范式语言，允许你自由地混合和使用面向对象式、过程式和函数式的编程范式。最近，函数式编程越来越火热。在诸如 Angular 和 React 这样的框架中，通过使用不可变数据结构可以切实提高性能。不可变是函数式编程的核心原则，它以及纯函数使得编写和调试程序变得更加容易。使用函数来代替程序的循环可以提高程序的可读性并使它更加优雅。总之，函数式编程拥有很多优点。什么不是函数式编程在讨论什么是函数式编程前，让我们先排除那些不属于函数式编程的东西。实际上它们是你需要丢弃的语言组件（再见，老朋友）：循环：whiledo...whileforfor...offor...in用 var 或者 let 来声明变量没有返回值的函数改变对象的属性 (比如: o.x = 5;)改变数组本身的方法：copyWithinfillpoppushreverseshiftsortspliceunshift改变映射本身的方法：cleardeleteset改变集合本身的方法：addcleardelete脱离这些特性应该如何编写程序呢？这是我们将在后面探索的问题。纯函数你的程序中包含函数不一定意味着你正在进行函数式编程。函数式范式将 纯函数 pure function 和 非纯函数 impure function 区分开。鼓励你编写纯函数。纯函数必须满足下面的两个属性：引用透明：函数在传入相同的参数后永远返回相同的返回值。这意味着该函数不依赖于任何可变状态。无副作用：函数不能导致任何副作用。副作用可能包括 I/O（比如向终端或者日志文件写入），改变一个不可变的对象，对变量重新赋值等等。我们来看一些例子。首先，multiply 就是一个纯函数的例子，它在传入相同的参数后永远返回相同的返回值，并且不会导致副作用。function multiply(a, b) { return a * b; } 下面是非纯函数的例子。canRide 函数依赖捕获的 heightRequirement 变量。被捕获的变量不一定导致一个函数是非纯函数，除非它是一个可变的变量（或者可以被重新赋值）。这种情况下使用 let 来声明这个变量，意味着可以对它重新赋值。multiply 函数是非纯函数，因为它会导致在 console 上输出。let heightRequirement = 46; // Impure because it relies on a mutable (reassignable) variable. function canRide(height) { return height >= heightRequirement; } // Impure because it causes a side-effect by logging to the console. function multiply(a, b) { console.log('Arguments: ', a, b); return a * b; } 下面的列表包含着 JavaScript 内置的非纯函数。你可以指出它们不满足两个属性中的哪个吗？console.logelement.addEventListenerMath.randomDate.now$.ajax (这里 $ 代表你使用的 Ajax 库)理想的程序中所有的函数都是纯函数，但是从上面的函数列表可以看出，任何有意义的程序都将包含非纯函数。大多时候我们需要进行 AJAX 调用，检查当前日期或者获取一个随机数。一个好的经验法则是遵循 80/20 规则：函数中有 80％ 应该是纯函数，剩下的 20％ 的必要性将不可避免地是非纯函数。使用纯函数有几个优点：它们很容易导出和调试，因为它们不依赖于可变的状态。返回值可以被缓存或者“记忆”来避免以后重复计算。它们很容易测试，因为没有需要模拟（mock）的依赖（比如日志，AJAX，数据库等等）。你编写或者使用的函数返回空（换句话说它没有返回值），那代表它是非纯函数。不变性让我们回到捕获变量的概念上。来看看 canRide 函数。我们认为它是一个非纯函数，因为 heightRequirement 变量可以被重新赋值。下面是一个构造出来的例子来说明如何用不可预测的值来对它重新赋值。let heightRequirement = 46; function canRide(height) { return height >= heightRequirement; } // Every half second, set heightRequirement to a random number between 0 and 200. setInterval(() => heightRequirement = Math.floor(Math.random() * 201), 500); const mySonsHeight = 47; // Every half second, check if my son can ride. // Sometimes it will be true and sometimes it will be false. setInterval(() => console.log(canRide(mySonsHeight)), 500); 我要再次强调被捕获的变量不一定会使函数成为非纯函数。我们可以通过只是简单地改变 heightRequirement 的声明方式来使 canRide 函数成为纯函数。const heightRequirement = 46; function canRide(height) { return height >= heightRequirement; } 通过用 const 来声明变量意味着它不能被再次赋值。如果尝试对它重新赋值，运行时引擎将抛出错误；那么，如果用对象来代替数字来存储所有的“常量”怎么样？const constants = { heightRequirement: 46, // ... other constants go here }; function canRide(height) { return height >= constants.heightRequirement; } 我们用了 const ，所以这个变量不能被重新赋值，但是还有一个问题：这个对象可以被改变。下面的代码展示了，为了真正使其不可变，你不仅需要防止它被重新赋值，你也需要不可变的数据结构。JavaScript 语言提供了 Object.freeze 方法来阻止对象被改变。'use strict'; // CASE 1: 对象的属性是可变的，并且变量可以被再次赋值。 let o1 = { foo: 'bar' }; // 改变对象的属性 o1.foo = 'something different'; // 对变量再次赋值 o1 = { message: "I'm a completely new object" }; // CASE 2: 对象的属性还是可变的，但是变量不能被再次赋值。 const o2 = { foo: 'baz' }; // 仍然能改变对象 o2.foo = 'Something different, yet again'; // 不能对变量再次赋值 // o2 = { message: 'I will cause an error if you uncomment me' }; // Error! // CASE 3: 对象的属性是不可变的，但是变量可以被再次赋值。 let o3 = Object.freeze({ foo: "Can't mutate me" }); // 不能改变对象的属性 // o3.foo = 'Come on, uncomment me. I dare ya!'; // Error! // 还是可以对变量再次赋值 o3 = { message: "I'm some other object, and I'm even mutable -- so take that!" }; // CASE 4: 对象的属性是不可变的，并且变量不能被再次赋值。这是我们想要的！！！！！！！！ const o4 = Object.freeze({ foo: 'never going to change me' }); // 不能改变对象的属性 // o4.foo = 'talk to the hand' // Error! // 不能对变量再次赋值 // o4 = { message: "ain't gonna happen, sorry" }; // Error 不变性适用于所有的数据结构，包括数组、映射和集合。它意味着不能调用例如 Array.prototype.push 等会导致本身改变的方法，因为它会改变已经存在的数组。可以通过创建一个含有原来元素和新加元素的新数组，而不是将新元素加入一个已经存在的数组。其实所有会导致数组本身被修改的方法都可以通过一个返回修改好的新数组的函数代替。'use strict'; const a = Object.freeze([4, 5, 6]); // Instead of: a.push(7, 8, 9); const b = a.concat(7, 8, 9); // Instead of: a.pop(); const c = a.slice(0, -1); // Instead of: a.unshift(1, 2, 3); const d = [1, 2, 3].concat(a); // Instead of: a.shift(); const e = a.slice(1); // Instead of: a.sort(myCompareFunction); const f = R.sort(myCompareFunction, a); // R = Ramda // Instead of: a.reverse(); const g = R.reverse(a); // R = Ramda // 留给读者的练习: // copyWithin // fill // splice 映射 和 集合 也很相似。可以通过返回一个新的修改好的映射或者集合来代替使用会修改其本身的函数。const map = new Map([ [1, 'one'], [2, 'two'], [3, 'three'] ]); // Instead of: map.set(4, 'four'); const map2 = new Map([...map, [4, 'four']]); // Instead of: map.delete(1); const map3 = new Map([...map].filter(([key]) => key !== 1)); // Instead of: map.clear(); const map4 = new Map(); const set = new Set(['A', 'B', 'C']); // Instead of: set.add('D'); const set2 = new Set([...set, 'D']); // Instead of: set.delete('B'); const set3 = new Set([...set].filter(key => key !== 'B')); // Instead of: set.clear(); const set4 = new Set(); 我想提一句如果你在使用 TypeScript（我非常喜欢 TypeScript），你可以用 Readonly<T>、ReadonlyArray<T>、ReadonlyMap<K, V> 和 ReadonlySet<T> 接口来在编译期检查你是否尝试更改这些对象，有则抛出编译错误。如果在对一个对象字面量或者数组调用 Object.freeze，编译器会自动推断它是只读的。由于映射和集合在其内部表达，所以在这些数据结构上调用 Object.freeze 不起作用。但是你可以轻松地告诉编译器它们是只读的变量。TypeScript 只读接口好，所以我们可以通过创建新的对象来代替修改原来的对象，但是这样不会导致性能损失吗？当然会。确保在你自己的应用中做了性能测试。如果你需要提高性能，可以考虑使用 Immutable.js。Immutable.js 用持久的数据结构 实现了链表、堆栈、映射、集合和其他数据结构。使用了如同 Clojure 和 Scala 这样的函数式语言中相同的技术。// Use in place of `[]`. const list1 = Immutable.List(['A', 'B', 'C']); const list2 = list1.push('D', 'E'); console.log([...list1]); // ['A', 'B', 'C'] console.log([...list2]); // ['A', 'B', 'C', 'D', 'E'] // Use in place of `new Map()` const map1 = Immutable.Map([ ['one', 1], ['two', 2], ['three', 3] ]); const map2 = map1.set('four', 4); console.log([...map1]); // [['one', 1], ['two', 2], ['three', 3]] console.log([...map2]); // [['one', 1], ['two', 2], ['three', 3], ['four', 4]] // Use in place of `new Set()` const set1 = Immutable.Set([1, 2, 3, 3, 3, 3, 3, 4]); const set2 = set1.add(5); console.log([...set1]); // [1, 2, 3, 4] console.log([...set2]); // [1, 2, 3, 4, 5]函数组合记不记得在中学时我们学过一些像 (f ∘ g)(x) 的东西？你那时可能想，“我什么时候会用到这些？”，好了，现在就用到了。你准备好了吗？f ∘ g读作 “函数 f 和函数 g 组合”。对它的理解有两种等价的方式，如等式所示： (f ∘ g)(x) = f(g(x))。你可以认为 f ∘ g 是一个单独的函数，或者视作将调用函数 g 的结果作为参数传给函数 f。注意这些函数是从右向左依次调用的，先执行 g，接下来执行 f。关于函数组合的几个要点:我们可以组合任意数量的函数（不仅限于 2 个）。组合函数的一个方式是简单地把一个函数的输出作为下一个函数的输入（比如 f(g(x))）。// h(x) = x + 1 // number -> number function h(x) { return x + 1; } // g(x) = x^2 // number -> number function g(x) { return x * x; } // f(x) = convert x to string // number -> string function f(x) { return x.toString(); } // y = (f ∘ g ∘ h)(1) const y = f(g(h(1))); console.log(y); // '4' Ramda 和 lodash 之类的库提供了更优雅的方式来组合函数。我们可以在更多的在数学意义上处理函数组合，而不是简单地将一个函数的返回值传递给下一个函数。我们可以创建一个由这些函数组成的单一复合函数(就是 (f ∘ g)(x))。// h(x) = x + 1 // number -> number function h(x) { return x + 1; } // g(x) = x^2 // number -> number function g(x) { return x * x; } // f(x) = convert x to string // number -> string function f(x) { return x.toString(); } // R = Ramda // composite = (f ∘ g ∘ h) const composite = R.compose(f, g, h); // Execute single function to get the result. const y = composite(1); console.log(y); // '4' 好了，我们可以在 JavaScript 中组合函数了。接下来呢？好，如果你已经入门了函数式编程，理想中你的程序将只有函数的组合。代码里没有循环（for, for...of, for...in, while, do），基本没有。你可能觉得那是不可能的。并不是这样。我们下面的两个话题是：递归和高阶函数。递归假设你想实现一个计算数字的阶乘的函数。 让我们回顾一下数学中阶乘的定义：n! = n * (n-1) * (n-2) * ... * 1.n! 是从 n 到 1 的所有整数的乘积。我们可以编写一个循环轻松地计算出结果。function iterativeFactorial(n) { let product = 1; for (let i = 1; i <= n; i++) { product *= i; } return product; } 注意 product 和 i 都在循环中被反复重新赋值。这是解决这个问题的标准过程式方法。如何用函数式的方法解决这个问题呢？我们需要消除循环，确保没有变量被重新赋值。递归是函数式程序员的最有力的工具之一。递归需要我们将整体问题分解为类似整体问题的子问题。计算阶乘是一个很好的例子，为了计算 n! 我们需要将 n 乘以所有比它小的正整数。它的意思就相当于：n! = n * (n-1)! 啊哈！我们发现了一个解决 (n-1)! 的子问题，它类似于整个问题 n!。还有一个需要注意的地方就是基础条件。基础条件告诉我们何时停止递归。 如果我们没有基础条件，那么递归将永远持续。 实际上，如果有太多的递归调用，程序会抛出一个堆栈溢出错误。啊哈！function recursiveFactorial(n) { // Base case -- stop the recursion if (n === 0) { return 1; // 0! is defined to be 1. } return n * recursiveFactorial(n - 1); } 然后我们来计算 recursiveFactorial(20000) 因为……，为什么不呢？当我们这样做的时候，我们得到了这个结果：堆栈溢出错误这里发生了什么？我们得到一个堆栈溢出错误！这不是无穷的递归导致的。我们已经处理了基础条件(n === 0 的情况)。那是因为浏览器的堆栈大小是有限的，而我们的代码使用了越过了这个大小的堆栈。每次对 recursiveFactorial 的调用导致了新的帧被压入堆栈中，就像一个盒子压在另一个盒子上。每当 recursiveFactorial 被调用，一个新的盒子被放在最上面。下图展示了在计算 recursiveFactorial(3) 时堆栈的样子。注意在真实的堆栈中，堆栈顶部的帧将存储在执行完成后应该返回的内存地址，但是我选择用变量 r 来表示返回值，因为 JavaScript 开发者一般不需要考虑内存地址。")递归计算 3! 的堆栈（三次乘法）你可能会想象当计算 n = 20000 时堆栈会更高。我们可以做些什么优化它吗？当然可以。作为 ES2015 (又名 ES6) 标准的一部分，有一个优化用来解决这个问题。它被称作 尾调用优化 proper tail calls optimization （PTC）。当递归函数做的最后一件事是调用自己并返回结果的时候，它使得浏览器删除或者忽略堆栈帧。实际上，这个优化对于相互递归函数也是有效的，但是为了简单起见，我们还是来看单一递归函数。你可能会注意到，在递归函数调用之后，还要进行一次额外的计算（n * r）。那意味着浏览器不能通过 PTC 来优化递归；然而，我们可以通过重写函数使最后一步变成递归调用以便优化。一个窍门是将中间结果（在这里是 product）作为参数传递给函数。'use strict'; // Optimized for tail call optimization. function factorial(n, product = 1) { if (n === 0) { return product; } return factorial(n - 1, product * n) } 让我们来看看优化后的计算 factorial(3) 时的堆栈。如下图所示，堆栈不会增长到超过两层。原因是我们把必要的信息都传到了递归函数中（比如 product）。所以，在 product 被更新后，浏览器可以丢弃掉堆栈中原先的帧。你可以在图中看到每次最上面的帧下沉变成了底部的帧，原先底部的帧被丢弃，因为不再需要它了。 using PTC")递归计算 3! 的堆栈（三次乘法）使用 PTC现在选一个浏览器运行吧，假设你在使用 Safari，你会得到 Infinity（它是比在 JavaScript 中能表达的最大值更大的数）。但是我们没有得到堆栈溢出错误，那很不错！现在在其他的浏览器中呢怎么样呢？Safari 可能现在乃至将来是实现 PTC 的唯一一个浏览器。看看下面的兼容性表格：PTC 兼容性其他浏览器提出了一种被称作 语法级尾调用 syntactic tail calls （STC）的竞争标准。“语法级”意味着你需要用新的语法来标识你想要执行尾递归优化的函数。即使浏览器还没有广泛支持，但是把你的递归函数写成支持尾递归优化的样子还是一个好主意。高阶函数我们已经知道 JavaScript 将函数视作一等公民，可以把函数像其他值一样传递。所以，把一个函数传给另一个函数也很常见。我们也可以让函数返回一个函数。就是它！我们有高阶函数。你可能已经很熟悉几个在 Array.prototype 中的高阶函数。比如 filter、map 和 reduce 就在其中。对高阶函数的一种理解是：它是接受（一般会调用）一个回调函数参数的函数。让我们来看看一些内置的高阶函数的例子：const vehicles = [ { make: 'Honda', model: 'CR-V', type: 'suv', price: 24045 }, { make: 'Honda', model: 'Accord', type: 'sedan', price: 22455 }, { make: 'Mazda', model: 'Mazda 6', type: 'sedan', price: 24195 }, { make: 'Mazda', model: 'CX-9', type: 'suv', price: 31520 }, { make: 'Toyota', model: '4Runner', type: 'suv', price: 34210 }, { make: 'Toyota', model: 'Sequoia', type: 'suv', price: 45560 }, { make: 'Toyota', model: 'Tacoma', type: 'truck', price: 24320 }, { make: 'Ford', model: 'F-150', type: 'truck', price: 27110 }, { make: 'Ford', model: 'Fusion', type: 'sedan', price: 22120 }, { make: 'Ford', model: 'Explorer', type: 'suv', price: 31660 } ]; const averageSUVPrice = vehicles .filter(v => v.type === 'suv') .map(v => v.price) .reduce((sum, price, i, array) => sum + price / array.length, 0); console.log(averageSUVPrice); // 33399 注意我们在一个数组对象上调用其方法，这是面向对象编程的特性。如果我们想要更函数式一些，我们可以用 Rmmda 或者 lodash/fp 提供的函数。注意如果我们使用 R.compose 的话，需要倒转函数的顺序，因为它从右向左依次调用函数（从底向上）；然而，如果我们想从左向右调用函数就像上面的例子，我们可以用 R.pipe。下面两个例子用了 Rmmda。注意 Rmmda 有一个 mean 函数用来代替 reduce 。const vehicles = [ { make: 'Honda', model: 'CR-V', type: 'suv', price: 24045 }, { make: 'Honda', model: 'Accord', type: 'sedan', price: 22455 }, { make: 'Mazda', model: 'Mazda 6', type: 'sedan', price: 24195 }, { make: 'Mazda', model: 'CX-9', type: 'suv', price: 31520 }, { make: 'Toyota', model: '4Runner', type: 'suv', price: 34210 }, { make: 'Toyota', model: 'Sequoia', type: 'suv', price: 45560 }, { make: 'Toyota', model: 'Tacoma', type: 'truck', price: 24320 }, { make: 'Ford', model: 'F-150', type: 'truck', price: 27110 }, { make: 'Ford', model: 'Fusion', type: 'sedan', price: 22120 }, { make: 'Ford', model: 'Explorer', type: 'suv', price: 31660 } ]; // Using `pipe` executes the functions from top-to-bottom. const averageSUVPrice1 = R.pipe( R.filter(v => v.type === 'suv'), R.map(v => v.price), R.mean )(vehicles); console.log(averageSUVPrice1); // 33399 // Using `compose` executes the functions from bottom-to-top. const averageSUVPrice2 = R.compose( R.mean, R.map(v => v.price), R.filter(v => v.type === 'suv') )(vehicles); console.log(averageSUVPrice2); // 33399 使用函数式方法的优点是清楚地分开了数据（vehicles）和逻辑（函数 filter，map 和 reduce）。面向对象的代码相比之下把数据和函数用以方法的对象的形式混合在了一起。柯里化不规范地说， 柯里化 currying 是把一个接受 n 个参数的函数变成 n 个每个接受单个参数的函数的过程。函数的 arity 是它接受参数的个数。接受一个参数的函数是 unary，两个的是 binary，三个的是 ternary，n 个的是 n-ary。那么，我们可以把柯里化定义成将一个 n-ary 函数转换成 n 个 unary 函数的过程。让我们通过简单的例子开始，一个计算两个向量点积的函数。回忆一下线性代数，两个向量 [a, b, c] 和 [x, y, z] 的点积是 ax + by + cz。function dot(vector1, vector2) { return vector1.reduce((sum, element, index) => sum += element * vector2[index], 0); } const v1 = [1, 3, -5]; const v2 = [4, -2, -1]; console.log(dot(v1, v2)); // 1(4) + 3(-2) + (-5)(-1) = 4 - 6 + 5 = 3 dot 函数是 binary，因为它接受两个参数；然而我们可以将它手动转换成两个 unary 函数，就像下面的例子。注意 curriedDot 是一个 unary 函数，它接受一个向量并返回另一个接受第二个向量的 unary 函数。function curriedDot(vector1) { return function(vector2) { return vector1.reduce((sum, element, index) => sum += element * vector2[index], 0); } } // Taking the dot product of any vector with [1, 1, 1] // is equivalent to summing up the elements of the other vector. const sumElements = curriedDot([1, 1, 1]); console.log(sumElements([1, 3, -5])); // -1 console.log(sumElements([4, -2, -1])); // 1 很幸运，我们不需要把每一个函数都手动转换成柯里化以后的形式。Ramda 和 lodash 等库可以为我们做这些工作。实际上，它们是柯里化的混合形式。你既可以每次传递一个参数，也可以像原来一样一次传递所有参数。function dot(vector1, vector2) { return vector1.reduce((sum, element, index) => sum += element * vector2[index], 0); } const v1 = [1, 3, -5]; const v2 = [4, -2, -1]; // Use Ramda to do the currying for us! const curriedDot = R.curry(dot); const sumElements = curriedDot([1, 1, 1]); console.log(sumElements(v1)); // -1 console.log(sumElements(v2)); // 1 // This works! You can still call the curried function with two arguments. console.log(curriedDot(v1, v2)); // 3 Ramda 和 lodash 都允许你“跳过”一些变量之后再指定它们。它们使用置位符来做这些工作。因为点积的计算可以交换两项。传入向量的顺序不影响结果。让我们换一个例子来阐述如何使用一个置位符。Ramda 使用双下划线作为其置位符。const giveMe3 = R.curry(function(item1, item2, item3) { return ` 1: ${item1} 2: ${item2} 3: ${item3} `; }); const giveMe2 = giveMe3(R.__, R.__, 'French Hens'); // Specify the third argument. const giveMe1 = giveMe2('Partridge in a Pear Tree'); // This will go in the first slot. const result = giveMe1('Turtle Doves'); // Finally fill in the second argument. console.log(result); // 1: Partridge in a Pear Tree // 2: Turtle Doves // 3: French Hens 在我们结束探讨柯里化之前最后的议题是 偏函数应用 partial application 。偏函数应用和柯里化经常同时出场，尽管它们实际上是不同的概念。一个柯里化的函数还是柯里化的函数，即使没有给它任何参数。偏函数应用，另一方面是仅仅给一个函数传递部分参数而不是所有参数。柯里化是偏函数应用常用的方法之一，但是不是唯一的。JavaScript 拥有一个内置机制可以不依靠柯里化来做偏函数应用。那就是 function.prototype.bind 方法。这个方法的一个特殊之处在于，它要求你将 this 作为第一个参数传入。 如果你不进行面向对象编程，那么你可以通过传入 null 来忽略 this。1function giveMe3(item1, item2, item3) { return ` 1: ${item1} 2: ${item2} 3: ${item3} `; } const giveMe2 = giveMe3.bind(null, 'rock'); const giveMe1 = giveMe2.bind(null, 'paper'); const result = giveMe1('scissors'); console.log(result); // 1: rock // 2: paper // 3: scissors 总结我希望你享受探索 JavaScript 中函数式编程的过程。对一些人来说，它可能是一个全新的编程范式，但我希望你能尝试它。你会发现你的程序更易于阅读和调试。不变性还将允许你优化 Angular 和 React 的性能。这篇文章基于 Matt 在 OpenWest 的演讲 JavaScript the Good-er Parts. OpenWest 将在 6/12-15 ,2017 在 Salt Lake City, Utah 举行。作者简介：Matt Banz - Matt 于 2008 年五月在犹他大学获得了数学学位毕业。一个月后他得到了一份 web 开发者的工作，他从那时起就爱上了它！在 2013 年，他在北卡罗莱纳州立大学获得了计算机科学硕士学位。他在 LDS 商学院和戴维斯学区社区教育计划教授 Web 课程。他现在是就职于 Motorola Solutions 公司的高级前端开发者。via: https://opensource.com/article/17/6/functional-javascript作者：Matt Banz 译者：trnhoe 校对：wxy本文由 LCTT 原创编译，Linux中国 荣誉推出
我们来解释函数式编程的什么，它的优点是哪些，并且给出一些函数式编程的学习资源。这要看您问的是谁， 函数式编程 functional programming （FP）要么是一种理念先进的、应该广泛传播的程序设计方法；要么是一种偏学术性的、实际用途不多的编程方式。在这篇文章中我将讲解函数式编程，探究其优点，并推荐学习函数式编程的资源。语法入门本文的代码示例使用的是 Haskell 编程语言。在这篇文章中你只需要了解的基本函数语法：even :: Int -> Bool even = ... -- 具体的实现放在这里 上述示例定义了含有一个参数的函数 even ，第一行是 类型声明，具体来说就是 even 函数接受一个 Int 类型的参数，返回一个 Bool 类型的值，其实现跟在后面，由一个或多个等式组成。在这里我们将忽略具体实现方法（名称和类型已经足够了）：map :: (a -> b) -> [a] -> [b] map = ... 这个示例，map 是一个有两个参数的函数：(a -> b) ：将 a 转换成 b 的函数[a]：一个 a 的列表，并返回一个 b 的列表。（LCTT 译注： 将函数作用到 [a] （List 序列对应于其它语言的数组）的每一个元素上，将每次所得结果放到另一个 [b] ，最后返回这个结果 [b]。）同样我们不去关心要如何实现，我们只感兴趣它的定义类型。a 和 b 是任何一种的的 类型变量 type variable 。就像上一个示例中， a 是 Int 类型， b 是 Bool 类型:map even [1,2,3] 这个是一个 Bool 类型的序列：[False,True,False] 如果你看到你不理解的其他语法，不要惊慌；对语法的充分理解不是必要的。函数式编程的误区我们先来解释一下常见的误区：函数式编程不是命令行编程或者面向对象编程的竞争对手或对立面，这并不是非此即彼的。函数式编程不仅仅用在学术领域。这是真的，在函数式编程的历史中，如像 Haskell 和 OCaml 语言是最流行的研究语言。但是今天许多公司使用函数式编程来用于大型的系统、小型专业程序，以及种种不同场合。甚至还有一个面向函数式编程的商业用户[33的年度会议；以前的那些程序让我们了解了函数式编程在工业中的用途，以及谁在使用它。函数式编程与 monad 无关 ，也不是任何其他特殊的抽象。在这篇文章里面 monad 只是一个抽象的规定。有些是 monad，有些不是。函数式编程不是特别难学的。某些语言可能与您已经知道的语法或求值语义不同，但这些差异是浅显的。函数式编程中有大量的概念，但其他语言也是如此。什么是函数式编程?核心是函数式编程是只使用纯粹的数学函数编程，函数的结果仅取决于参数，而没有副作用，就像 I/O 或者状态转换这样。程序是通过 组合函数 function composition 的方法构建的：(.) :: (b -> c) -> (a -> b) -> (a -> c) (g . f) x = g (f x) 这个 中缀 infix 函数 (.) 表示的是二个函数组合成一个，将 g 作用到 f 上。我们将在下一个示例中看到它的使用。作为比较，我们看看在 Python 中同样的函数：def compose(g, f): return lambda x: g(f(x)) 函数式编程的优点在于：由于函数是确定的、没有副作用的，所以可以用结果替换函数，这种替代等价于使用使 等式推理 equational reasoning 。每个程序员都有使用自己代码和别人代码的理由，而等式推理就是解决这样问题不错的工具。来看一个示例。等你遇到这个问题：map even . map (+1) 这段代码是做什么的？可以简化吗？通过等式推理，可以通过一系列替换来分析代码：map even . map (+1) map (even . (+1)) -- 来自 'map' 的定义 map (\x -> even (x + 1)) -- lambda 抽象 map odd -- 来自 'even' 的定义 我们可以使用等式推理来理解程序并优化可读性。Haskell 编译器使用等式推理进行多种程序优化。没有纯函数，等式推理是不可能的，或者需要程序员付出更多的努力。函数式编程语言你需要一种编程语言来做函数式编程吗？在没有 高阶函数 higher-order function （传递函数作为参数和返回函数的能力）、lambdas （匿名函数）和 泛型 generics 的语言中进行有意义的函数式编程是困难的。 大多数现代语言都有这些，但在不同语言中支持函数式编程方面存在差异。 具有最佳支持的语言称为 函数式编程语言 functional programming language 。 这些包括静态类型的 Haskell、OCaml、F# 和 Scala ，以及动态类型的 Erlang 和 Clojure。即使是在函数式语言里，可以在多大程度上利用函数编程有很大差异。有一个 类型系统 type system 会有很大的帮助，特别是它支持 类型推断 type inference 的话（这样你就不用总是必须键入类型）。这篇文章中没有详细介绍这部分，但足以说明，并非所有的类型系统都是平等的。与所有语言一样，不同的函数的语言强调不同的概念、技术或用例。选择语言时，考虑它支持函数式编程的程度以及是否适合您的用例很重要。如果您使用某些非 FP 语言，你仍然会受益于在该语言支持的范围内的函数式编程。不要打开陷阱之门回想一下，函数的结果只取决于它的输入。但是，几乎所有的编程语言都有破坏这一原则的“功能”。空值、 实例类型 type case （instanceof）、类型转换、异常、 边际效用 side-effect ，以及无尽循环的可能性都是陷阱，它打破等式推理，并削弱程序员对程序行为正确性的理解能力。（所有语言里面，没有任何陷阱的语言包括 Agda、Idris 和 Coq。）幸运的是，作为程序员，我们可以选择避免这些陷阱，如果我们受到严格的规范，我们可以假装陷阱不存在。 这个方法叫做 轻率推理 fast and loose reasoning 。它不需要任何条件，几乎任何程序都可以在不使用陷阱的情况下进行编写，并且通过避免这些可以而获得等式推理、可组合性和可重用性。让我们详细讨论一下。 这个陷阱破坏了等式推理，因为异常终止的可能性没有反映在类型中。（你可以庆幸文档中甚至没有提到能抛出的异常）。但是没有理由我们没有一个可以包含所有故障模式的返回类型。避开陷阱是语言特征中出现很大差异的领域。为避免例外， 代数数据类型 algebraic data type 可用于模型错误的条件下，就像：-- new data type for results of computations that can fail -- data Result e a = Error e | Success a -- new data type for three kinds of arithmetic errors -- data ArithError = DivByZero | Overflow | Underflow -- integer division, accounting for divide-by-zero -- safeDiv :: Int -> Int -> Result ArithError Int safeDiv x y = if y == 0 then Error DivByZero else Success (div x y) 在这个例子中的权衡你现在必须使用 Result ArithError Int 类型，而不是以前的 Int 类型，但这也是解决这个问题的一种方式。你不再需要处理异常，而能够使用轻率推理 ，总体来说这是一个胜利。自由定理大多数现代静态类型语言具有 范型 generics （也称为 参数多态性 parametric polymorphism ），其中函数是通过一个或多个抽象类型定义的。 例如，看看这个 List（序列）函数:f :: [a] -> [a] f = ... Java 中的相同函数如下所示：static List f(List xs) { ... } 该编译的程序证明了这个函数适用于类型 a 的任意选择。考虑到这一点，采用轻率推理的方法，你能够弄清楚该函数的作用吗？知道类型有什么帮助？在这种情况下，该类型并不能告诉我们函数的功能（它可以逆转序列、删除第一个元素，或许多其它的操作），但它确实告诉了我们很多信息。只是从该类型，我们可以推演出该函数的定理：定理 1 ：输出中的每个元素也出现于输入中；不可能在输入的序列 a 中添加值，因为你不知道 a 是什么，也不知道怎么构造一个。定理 2 ：如果你映射某个函数到列表上，然后对其应用 f，其等同于对映射应用 f。定理 1 帮助我们了解代码的作用，定理 2 对于程序优化提供了帮助。我们从类型中学到了这一切！其结果，即从类型中获取有用的定理的能力，称之为 参数化 parametricity 。因此，类型是函数行为的部分（有时是完整的）规范，也是一种机器检查机制。现在你可以利用参数化了。你可以从 map 和 (.) 的类型或者下面的这些函数中发现什么呢？foo :: a -> (a, a)bar :: a -> a -> abaz :: b -> a -> a学习功能编程的资源也许你已经相信函数式编程是编写软件不错的方式，你想知道如何开始？有几种学习功能编程的方法；这里有一些我推荐（我承认，我对 Haskell 偏爱）：UPenn 的 CIS 194: 介绍 Haskell 是函数式编程概念和 Haskell 实际开发的不错选择。有课程材料，但是没有讲座（您可以用几年前 Brisbane 函数式编程小组的 CIS 194 系列讲座。不错的入门书籍有 《Scala 的函数式编程》 、 《Haskell 函数式编程思想》 , 和 《Haskell 编程原理》。Data61 FP 课程 （即 NICTA 课程）通过 类型驱动开发 type-driven development 来教授基础的抽象概念和数据结构。这是十分困难，但收获也是丰富的，其起源于培训会，如果你有一名愿意引导你函数式编程的程序员，你可以尝试。在你的工作学习中使用函数式编程书写代码，写一些纯函数（避免不确定性和异常的出现），使用高阶函数和递归而不是循环，利用参数化来提高可读性和重用性。许多人从体验和实验各种语言的美妙之处，开始走上了函数式编程之旅。加入到你的地区中的一些函数式编程小组或者学习小组中，或者创建一个，也可以是参加一些函数式编程的会议（新的会议总是不断的出现）。总结在本文中，我讨论了函数式编程是什么以及不是什么，并了解到了函数式编程的优势，包括等式推理和参数化。我们了解到在大多数编程语言中都有一些函数式编程功能，但是语言的选择会影响受益的程度，而 Haskell 是函数式编程中语言最受欢迎的语言。我也推荐了一些学习函数式编程的资源。函数式编程是一个丰富的领域，还有许多更深入（更神秘）的主题正在等待探索。我没有提到那些具有实际意义的事情，比如：lenses 和 prisms （是一流的设置和获取值的方式；非常适合使用嵌套数据）；定理证明（当你可以证明你的代码正确时，为什么还要测试你的代码？）；延迟评估（让您处理潜在的无数的数据结构）；分类理论（函数式编程中许多美丽实用的抽象的起源）；我希望你喜欢这个函数式编程的介绍，并且启发你走上这个有趣和实用的软件开发之路。本文根据 CC BY 4.0 许可证发布。（题图: opensource.com）作者简介：红帽软件工程师。对函数式编程，分类理论，数学感兴趣。Crazy about jalapeños.via: https://opensource.com/article/17/4/introduction-functional-programming作者：Fraser Tweedale 译者：MonkeyDEcho 校对：wxy本文由 LCTT 原创编译，Linux中国 荣誉推出