函数式编程：一等函数（First-class Function）
说起函数式编程，不得不提的是First-class Function的概念，有些文章把它翻译成“第一类函数”，有些是“一等函数”，我更倾向于“一等函数”，因为这种名字更能体现出“一等数据类型”的概念。那么什么是一等函数呢？它指的是带有最少限制的函数，它们的“权利或者特权包括”：
- 可以用变量命名
- 可以提供给过程作为参数
- 可以由过程作为结果返回
- 可以包含在数据结构中
这样的函数就跟字符串一样，可以传来传去，也就成了一种“数据”。接下来分别介绍这四个特征的一些应用。（本文示例以最常见的Javascript为主，但也会给出Java的示例，作为强类型语言的参考）。
特征一：可以用变量命名
首先来看一个js的例子
function hello(){
console.log("hello")
}
let funHello = hello
funHello();
这里定义了一个函数hello，然后将其和变量funHello绑定，然后对变量funHello进行函数调用，结果就是hello函数被调用。
可以用变量命名这点非常重要，因为变量可以作为参数传递，可以用来接收过程调用的返回值，也可以作为例如json对象、结构体的属性，所以函数也可以被用来干这些事。例如：
当然在js里还可以这样编写：
let funHello1 = function (){
console.log("hello")
}
let funHello2 = () => {
console.log("hello")
}
但是到Java这边，由于Java是强类型语言，而Java实现上并没有对一等函数的直接支持，所以只能用Java 8的函数式接口来实现这样的表达：
public class FunMain {
static void hello(){
System.out.println("hello");
}
public static void main(String[] args) {
Runnable r = FunMain::hello;
r.run();
Runnable r1 = () -> {
System.out.println("hello");
};
r1.run();
}
}
特征二：可以提供给过程作为参数
这点应用就比较广泛了，各种高阶函数，例如回调函数：
function testCallback(callback){
console.log("do something....")
callback()
}
testCallback(() => {
console.log("complete...")
})
另外还有一个经典例子，比如，首先我们编写一个过滤出一个数组中偶数的数字：
function filterEven(nums){
let result = []
for(let i = 0;i < nums.length;i++){
if(nums[i] %2 == 0){
result.push(nums[i])
}
}
return result;
}
filterEven([1,2,3,4,5,6]) // => [2,4,6]
然后来了个新的功能，要编写一个过滤出1-10之间数：
function filter1to10(nums){
let result = []
for(let i = 0;i < nums.length;i++){
if(nums[i] >= 1 && nums[i] <= 10){
result.push(nums[i])
}
}
return result;
}
filter1to10([1,22,3,44,5,66]) //=> [1,3,5]
其实大家会发现代码结构非常类似，只有判断条件不同，我们将其提取成参数后：
function filter(datas, predicte){
let result = []
for(let i = 0;i < datas.length;i++){
if(predicte(datas[i])){
result.push(datas[i])
}
}
return result;
}
filter([1,2,3,4,5,6], i => i % 2 == 0)
filter([1,22,3,44,5,66], i => i >= 1 && i <= 10)
这样代码的复用性就得到了很大提升，下面要过滤不同类型的数值，只需要传入不同的条件就可以了。
Java版本的如下：
public class FunMain {
public static void main(String[] args) {
List<Integer> list1 = filterInts(Arrays.asList(1, 2, 3, 4, 5), i -> i % 2 == 0);
}
public static List<Integer> filterInts(List<Integer> list, Predicate<? super Integer> predicate) {
List<Integer> result = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
Integer data = list.get(i);
if (predicate.test(data)) {
result.add(data);
}
}
return result;
}
}
还可以利用泛型做进一步优化：
public class FunMain {
public static void main(String[] args) {
List<Integer> list1 = filter(Arrays.asList(1, 22, 3, 44, 5,66), i -> i >= 1 && i <= 10);
}
public static <T> List<T> filter(List<T> list, Predicate<? super T> predicate) {
List<T> result = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
T data = list.get(i);
if (predicate.test(data)) {
result.add(data);
}
}
return result;
}
}
public class FunMain {
public static void main(String[] args) {
List<Integer> list1 = filter(Arrays.asList(1, 22, 3, 44, 5,66), i -> i >= 1 && i <= 10);
}
public static <T> List<T> filter(List<T> list, Predicate<? super T> predicate) {
List<T> result = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
T data = list.get(i);
if (predicate.test(data)) {
result.add(data);
}
}
return result;
}
}
特征三：可以由过程作为结果返回
这一点说得通俗点就是返回函数的函数，或者说函数生成器。例如，我们考虑下面这样的一个加法器：
function adder(n){
return i => {
return i + n
}
}
let add3 = adder(3);
add3(4) // => 7
add3(10) // => 13
这里函数adder接受一个数字n，返回一个将参数加n的函数。
对应Java版本为：
public class FunMain {
public static void main(String[] args) {
Function<Integer, Integer> add3 = adder(3);
int r = add3.apply(4);// => 7
System.out.println(r);
}
static Function<Integer, Integer> adder(int n){
return i -> {
return i + n;
};
}
}
我们还可以编写反函数的生成器：
function complement(f){
return n => !f(n)
}
function odd(n){
return n % 2 != 0;
}
let even = complement(odd)
odd(1)
even(2)
对应的Java版本为：
public class FunMain {
public static void main(String[] args) {
Predicate<Integer> odd = i -> i % 2 != 0;
Predicate<Integer> even = complement(odd);
System.out.println(odd.test(1) + " - " + even.test(2));
}
static <T> Predicate<T> complement(Predicate<T> predicate) {
return t -> !predicate.test(t);
}
}
另外，我们还可以和特征二结合起来实现函数组合的效果：
function compose (f1, f2){
return i => f2(f1(i))
}
function square (n){
return n * n
}
function triple(n){
return 3 * n
}
let squareAndTriple = compose(square, triple);
squareAndTriple(4) // => 48
这里我们利用compose把两个单参函数square和triple组合，得到一个新的函数squareAndTriple。对应Java版本为：
public class FunMain {
public static void main(String[] args) {
Function<Integer, Integer> squareAndTriple = compose(FunMain::square, FunMain::triple);
Integer r = squareAndTriple.apply(4);
System.out.println(r);
}
static int square(int n) {
return n * n;
}
static int triple(int n) {
return 3 * n;
}
static <T, K, R> Function<T, R> compose(Function<T, K> f1, Function<K, R> f2) {
return t -> f2.apply(f1.apply(t));
}
}
特征四：可以包含在数据结构中
这一点意味着，函数可以作为集合的元素，也可以作为对象的属性等等，例如，我们可以得到一个函数序列：
function identity(i){
return i
}
let funList = [
i => i * i,
function (i){
return i + 1
},
identity
]
for(let i = 0;i < funList.length;i++){
console.log(funList[i](10))
}
对应Java版本为：
public class FunMain {
public static void main(String[] args) {
List<Function<Integer, Integer>> list = Arrays.asList(
i -> i * i,
i -> i + 1,
FunMain::identity
);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).apply(10));
}
}
static int identity(int n) {
return n;
}
}
180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
