共计 6883 个字符，预计需要花费 18 分钟才能阅读完成。
如函数式编程 – 酷壳 总结，
函数式编程的三大个性;
- 数据不可变性
- 函数作为一等公民(函数能够像变量一样来创立 / 批改 / 传递 等)
- 尾递归优化(重用 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()办法
- 首先，创立了一个与之前雷同的蕴含三个字符串的数组
arr。 - 应用
iter()办法创立一个数组的迭代器。 - 应用
map()办法对迭代器中的每个元素进行转换操作。这里应用了一个闭包|s| s.to_ascii_uppercase()，它将每个字符串转换为大写模式。 - 应用
collect()办法将转换后的后果收集到一个Vec<String>中。 - 应用
try_into()办法将Vec<String>转换为[String; 3]类型的新数组new_arr。这里应用了try_into()，它尝试将Vec<String>转换为[String; 3]，如果转换失败则会返回一个谬误。 - 最初，应用
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::Addtrait，这容许咱们对类型T的值进行加法操作，并失去类型T的后果。T: Copy：要求类型T实现了Copytrait，这容许咱们对类型T进行复制操作，以防止所有权转移的问题。T: Default：要求类型T实现了Defaulttrait，这容许咱们应用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 多平台公布