初探函数式编程---以Map/Reduce/Filter为例

头像
好文收藏
     北京
    阅读 8 分钟

    如函数式编程--酷壳 总结，

    函数式编程的三大特性;

    • 数据不可变性
    • 函数作为一等公民(函数可以像变量一样来创建/修改/传递 等)
    • 尾递归优化(重用stack,减轻栈的压力)


    函数式编程用到的几个技术：


    函数式编程的理念：把函数当成变量来用，关注于描述问题而不是怎么实现（这样可以让代码更易读）



    下面详细探讨 Map、Reduce、Filter，这三种操作可以非常方便灵活地对一些数据进行处理，而不是大量使用for循环

    （有的也把Reduce称为fold；比较早期且经典的函数式语言有OCaml， Lisp，Haskell等)

    其实恰好对应PHP中的array_map()、array_reduce()、array_filter()


    Map


    如 有这样一个人名的集合["ZhangSan","lisi","WANGWU"]，有大写有小写，将其全部转为大写，

    Go语言版本

    对于传统方式，对切片进行循环，在循环中进行处理即可：

    
func UpperSli(arr []string) (newArr []string) {
    for _, item := range arr {
        newArr = append(newArr, strings.ToUpper(item))
    }
    return
}

func main() {

    arr := []string{"ZhangSan","lisi","WANGWU"}

    newArr := UpperSli(arr)

    fmt.Printf("%v\n", newArr)
    //[ZHANGSAN LISI WANGWU]

}

    “在函数式编程中，不应该用循环迭代的方式，而该用更为高级的方法”

    使用函数式编程的写法：

    
func MapStrUpper(arr []string, fn func(s string) string) []string {
    var newArray []string
    for _, it := range arr {
        newArray = append(newArray, fn(it))
    }
    return newArray
}

func main() {
    var list = []string{"ZhangSan","lisi","WANGWU"}

    x := MapStrUpper(list, func(s string) string {
        return strings.ToUpper(s)
    })

    fmt.Printf("%v\n", x)
     //[ZHANGSAN LISI WANGWU]
}

    “这样的代码很易读，因为，代码是在描述要干什么，而不是怎么干”


    PHP版本


    <?php

$arr = ["ZhangSan", "lisi", "WANGWU"];
var_export($arr);

$newArr = [];
foreach ($arr as $val) {
    $newVal = strtoupper($val);
    array_push($newArr, $newVal);
}

var_export($newArr);


    使用函数式编程的写法：

    <font size=1 color="grey">
    array_map()  函数可将用户自定义的函数作用到数组中的每个值上，并返回用户自定义函数作用后的带有新值的数组。

    可以传递多个数组，回调函数接受的参数数目应该和传递给 array_map() 函数的数组数目一致。

    </font>


    <?php

$arr = ["ZhangSan", "lisi", "WANGWU"];
var_export($arr);

$newArr = array_map(function ($val1) {
    return strtoupper($val1);
}, $arr);

var_export($newArr);


    Rust版本


    传统方式，对数组进行循环，在循环中进行处理：

    fn main() {
    let arr: [String;3] = ["ZhangSan".to_string(),"lisi".to_string(),"WANGWU".to_string()];
    println!("{:?}",arr);
    
     let  mut new_arr: [String;3] = ["".to_string(),"".to_string(),"".to_string()];
    
    // for i in arr.iter() {
    //     println!("值为 : {}", i);
    // }
    
    for index in 0..3 {
         println!("index is: {} & value is : {}",index,arr[index]);
         new_arr[index] = arr[index].to_ascii_uppercase();
    }
    
    
     println!("{:?}",new_arr);  
    
}

    输出：

    ["ZhangSan", "lisi", "WANGWU"]
// 值为 : ZhangSan
// 值为 : lisi
// 值为 : WANGWU
index is: 0 & value is : ZhangSan
index is: 1 & value is : lisi
index is: 2 & value is : WANGWU
["ZHANGSAN", "LISI", "WANGWU"]


    麻雀虽小，却涉及到

    关于rust：如何打印结构和数组？ {:?}

    Rust 数组

    Rust中的String和&str


    函数式编程的方式：

    fn main() {
    let arr: [String; 3] = ["ZhangSan".to_string(), "lisi".to_string(), "WANGWU".to_string()];
    println!("{:?}", arr);
    
    let new_arr: [String; 3] = arr.iter()
        .map(|s| s.to_ascii_uppercase())
        .collect::<Vec<String>>()
        .try_into()
        .unwrap_or_else(|_| panic!("转换失败"));

    println!("{:?}", new_arr);
}

    这段代码主要使用了iter()、map()和collect()方法

    1. 首先，创建了一个与之前相同的包含三个字符串的数组 arr。
    2. 使用 iter() 方法创建一个数组的迭代器。
    3. 使用 map() 方法对迭代器中的每个元素进行转换操作。这里使用了一个闭包 |s| s.to_ascii_uppercase()，它将每个字符串转换为大写形式。
    4. 使用 collect() 方法将转换后的结果收集到一个 Vec<String> 中。
    5. 使用 try_into() 方法将 Vec<String> 转换为 [String; 3] 类型的新数组 new_arr。这里使用了 try_into()，它尝试将 Vec<String> 转换为 [String; 3]，如果转换失败则会返回一个错误。
    6. 最后，使用 println!("{:?}", new_arr) 打印新数组 new_arr 的内容。

    这种重构后的代码更加函数式和简洁，通过方法链式调用和闭包的组合，实现了对原始数组的转换。



    Reduce


    map()是将传入的函数依次作用到序列的每个元素，每个元素都是独自被函数“作用”一次;
    reduce()是将传入的函数作用在序列的第一个元素得到结果后，把这个结果继续与下一个元素作用（累积计算）

    reduce()方法是对数组的遍历,返回一个单个返回值

    如 有一个数字集合[1，4，7，2，8]，计算其和


    会把上一次迭代返回的结果存起来,带到下一次迭代中,使用reduce方法可以很容易的计算数组累加,累乘


    Go语言版本


    package main

import "fmt"

func Reduce(arr []int, fn func(s int) int) int {
    sum := 0
    for _, it := range arr {
        sum += fn(it)
    }
    return sum
}

func main() {
    var list = []int{1,4,7,2,8}

    x := Reduce(list, func(s int) int {
        return s
    })
    fmt.Printf("%v\n", x)
    // 22
}


    PHP版本


    <?php

function sum($carry, $item)
{
    var_dump($carry, $item);
    $carry += $item;
    echo "\n";
    return $carry;
}

$a = array(1, 4, 7, 2, 8);

$sum = array_reduce($a, 'sum', 0);

echo $sum;

    输出为：

    int(0)
int(1)

int(1)
int(4)

int(5)
int(7)

int(12)
int(2)

int(14)
int(8)

22

    更多参考

    array_reduce 的理解

    JS中的Array.reduce()方法方法")方法")


    Rust版本


    fn reduce<T, F>(arr: &[T], f: F) -> T
where
    T: std::ops::Add<Output = T> + Copy + Default,
    F: Fn(T) -> T,
{
    arr.iter().fold(T::default(), |acc, &item| acc + f(item))
}

fn main() {
    let list = vec![1, 4, 7, 2, 8];

    let x = reduce(&list, |s| s);

    println!("{:?}", x);
    // 输出：22
}

    这段代码实现了一个通用的归约函数 reduce，它接受一个泛型切片 arr 和一个泛型函数 f，并返回一个泛型类型 T。

    • reduce 函数使用了泛型类型参数 T 和 F。T 代表归约结果的类型，F 代表传入的函数的类型。

    • 在函数签名的 where 子句中，我们对类型参数 T 进行了约束条件：

      • T: std::ops::Add<Output = T>：要求类型 T 实现了 std::ops::Add trait，这允许我们对类型 T 的值进行加法操作，并得到类型 T 的结果。
      • T: Copy：要求类型 T 实现了 Copy trait，这允许我们对类型 T 进行复制操作，以避免所有权转移的问题。
      • T: Default：要求类型 T 实现了 Default trait，这允许我们使用 T::default() 获取类型 T 的默认值。
    • 函数体内部使用 arr.iter().fold() 方法进行归约操作。iter() 方法用于创建切片 arr 的迭代器，fold() 方法接受一个初始值 T::default() 和一个闭包作为参数。闭包中的 acc 是归约过程中的累加器，item 是切片中的每个元素。在闭包中，我们对累加器 acc 和传入闭包函数 f 处理后的元素 f(item) 执行加法操作，并将结果作为新的累加器返回。


    在 main 函数中，我们定义了一个整数切片 list，其中包含了一些整数。

    然后，我们调用了 reduce 函数，将整数切片 &list 和一个匿名闭包作为参数传入。这个匿名闭包的功能很简单，它只是返回传入的整数本身。

    reduce 函数会对整数切片中的每个元素应用传入的匿名闭包，并将所有元素的结果进行累加。最后，将归约结果打印出来。

    在这个例子中，整数切片中的元素分别为 1、4、7、2 和 8，对应的应用函数的结果也分别为 1、4、7、2 和 8。因此，最终的归约结果为 1 + 4 + 7 + 2 + 8 = 22。代码通过调用 println! 打印出结果 22。



    Filter


    Filter 重点在于过滤（而不是新增）某个元素

    如 有一个数字集合[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，筛选出哪些是奇数，哪些大于 5


    Go 版本
    package main

import "fmt"

func Filter(arr []int, fn func(n int) bool) []int {
    var newArray []int
    for _, it := range arr {
        if fn(it) {
            newArray = append(newArray, it)
        }
    }
    return newArray
}

func main() {
    var intset = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    out := Filter(intset, func(n int) bool {
        return n%2 == 1
    })
    fmt.Printf("%v\n", out) //[1 3 5 7 9]

    out = Filter(intset, func(n int) bool {
        return n > 5
    })
    fmt.Printf("%v\n", out) //[6 7 8 9 10]

}


    这段代码是一个示例程序，展示了在 Go 语言中使用函数式编程风格的过滤功能。

    首先，定义了一个名为 Filter 的函数，它接受一个整数切片 arr 和一个函数 fn 作为参数，返回一个新的整数切片。Filter 函数的作用是根据传入的函数 fn 对整数切片 arr 中的元素进行过滤，并返回符合条件的元素组成的新切片。

    在 main 函数中，创建了一个整数切片 intset，其中包含了 1 到 10 的整数。

    接下来，通过调用 Filter 函数进行过滤操作。第一次调用 Filter，传入的函数是一个匿名函数 func(n int) bool { return n%2 == 1 }，它的作用是判断一个整数是否为奇数。经过过滤，返回的结果是一个新的整数切片，其中包含原始切片中所有奇数值的元素。该结果通过 fmt.Printf 函数打印输出。

    第二次调用 Filter，传入的函数是另一个匿名函数 func(n int) bool { return n > 5 }，它的作用是判断一个整数是否大于 5。经过过滤，返回的结果是一个新的整数切片，其中包含原始切片中所有大于 5 的元素。同样地，该结果也通过 fmt.Printf 函数打印输出。

    以上这段代码展示了如何使用函数作为参数，实现对整数切片的过滤操作，并打印输出过滤后的结果。第一次过滤输出奇数，第二次过滤输出大于 5 的数。


    PHP 版本


    <?php

$arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

$newArr = array_filter($arr, function ($val) {
    return $val % 2 == 1;
});
//返回结果
var_export($newArr);


$newArr = array_filter($arr, function ($val) {
    return $val > 5;
});
//返回结果
var_export($newArr);

    输出：

    array (
  0 => 1,
  2 => 3,
  4 => 5,
  6 => 7,
  8 => 9,
)

array (
  5 => 6,
  6 => 7,
  7 => 8,
  8 => 9,
  9 => 10,
)


    Rust 版本


    fn main() {
    let intset = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    let out: Vec<i32> = filter(&intset, |&n| n % 2 == 1);
    println!("{:?}", out); // [1, 3, 5, 7, 9]

    let out: Vec<i32> = filter(&intset, |&n| n > 5);
    println!("{:?}", out); // [6, 7, 8, 9, 10]
}

fn filter<F>(arr: &[i32], predicate: F) -> Vec<i32>
where
    F: Fn(&i32) -> bool,
{
    arr.iter().cloned().filter(predicate).collect()
}


    可以借助 Rust 的函数式编程特性，如闭包和迭代器

    以上定义了一个 filter 函数，它接受一个整数切片 arr 和一个闭包 predicate 作为参数，并返回一个符合条件的整数切片。

    在 main 函数中，创建了一个整数向量 intset，其中包含了 1 到 10 的整数。

    通过调用 filter 函数，传入了一个匿名闭包作为 predicate 参数。这个闭包接受一个整数引用 &n，并返回一个布尔值，表示是否满足过滤条件。

    filter 函数通过使用迭代器方法链式调用的方式，对整数切片 arr 进行过滤。首先，使用 iter() 方法创建切片的迭代器，然后使用 cloned() 方法将整数引用转换为整数值的克隆。最后，使用 filter() 方法，传入闭包 predicate 进行过滤操作。

    过滤后的结果是一个迭代器，使用 collect() 方法将迭代器的元素收集到一个新的整数向量 Vec<i32> 中。

    最后，使用 println! 打印出过滤后的结果。

    整个重构后的代码保留了函数式编程的风格，使用闭包和迭代器实现了类似的过滤功能。第一次过滤输出奇数，第二次过滤输出大于 5 的数。


    array_filter() 重点在于过滤（而不是新增）某个元素，当你处理到一个元素时，返回过滤后的数组


    array_map() 重点在于遍历一个数组或多个数组的元素，返回一个新的数组


    array_walk() 重点在于遍历数组进行某种操作


    array_filter() 和 array_walk()对一个数组进行操作，数组参数在前，函数参数在后


    array_map() 可以处理多个数组，因此函数参数在前，数组参数在后，可以根据实际情况放入多个数组参数



    参考：

    GO编程模式：MAP-REDUCE

    robpike/filter

    array_filter()、array_map()、array_walk()三者的用法和区别、array_map()、array_walk()三者的用法和区别")、array_map()、array_walk()三者的用法和区别")

    更多可参见

    阮一峰-函数式编程初探

    阮一峰-函数式编程入门教程

    阮一峰-图解 Monad

    本文由mdnice多平台发布

    后端
    好文收藏
    38 声望6 粉丝

    好文收集

    « 上一篇
    Rust常用加密算法
    下一篇 »
    猜数游戏-Rust版

    引用和评论

    推荐阅读
    头像
    Go与黑客(第四部分)

    好文收藏

    头像
    Spring 实现 3 种异步流式接口，干掉接口超时烦恼

    程序员小富赞 5阅读 1.7k

    头像
    高质量代码的原则

    寒青赞 4阅读 5.4k

    头像
    日志与追踪的完美融合：OpenTelemetry MDC 实践指南

    crossoverJie赞 3阅读 1.8k

    头像
    Go 程序如何实现优雅退出？来看看 K8s 是怎么做的——上篇

    江湖十年赞 5阅读 791

    头像
    一文讲清楚static关键字

    seven97_top赞 4阅读 422

    头像
    每一个前端，都要拥有属于自己的埋点库~

    幸福的闹钟赞 2阅读 183

    0 条评论
    得票最新