Swift 函数式编程

Swift不仅支持面向对象编程, 也支持函数式编程, 这是一种新的编程范式,但这种编程思想很早就有了

1. 函数式编程的特质

• 模块化:
  函数式开发者更倾向于强调每个 程序都能够被反复分解为越来越小的模块单元，而所有这些块可以通过函数装配起来， 以定义一个完整的程序
• 对可变状态的谨慎处理:
  函数式编程有时候称为面向值编程。函数本身可以作为变量, 作为参数, 作为返回值.
  面向对象编程(命令式编程)专注于类和对象的设计，每个类和对象都有它们自己的封装状态。通过给对象发命令, 来实现各种操作.
• 类型
  一个设计良好的函数式程序在使用类型时应该相当谨慎。精心选择你的数 据和函数的类型，将会有助于构建你的代码，这比其他东西都重要

2. Swift中的Map，FlatMap, Filter, Reduce函数

• map

// 用在SequenceType (数组, 字典等), 也可用于Optionals (String等)
// map: 遍历元素, 对每个元素进行操作, 返回一个新的序列
func testMap() {
     let values = [1, 2, 3, 4]
     // 默认写法
     let result = values.map { (element) -> Int in
            return element * 2
     }
     // 精简写法
     let result2 = values.map({ $0 * 2 })
     let result3 = values.map_lc({ $0 * 3 })
     print("map:", result, result2, result3)  // [2, 4, 6, 8]
}

// 自定义实现map相关功能
// 遍历数组中的每一个元素, 并在闭包中做处理(+1, *2, *3等), 最后返回序列
func map_lc<T>(_ transform: (Element) -> T) -> [T] {
     var result = [T]()
     for x in self {
         result.append(transform(x))
     }
     return result
}

• flatMap

// flatMap: 降一维, 过滤nil
func testFlatMap() {
     let values = [[1, 2, 3], [4, 5, 6]]
     let values2 = [[["a", "b", "c"],["d", "e", "f"],["g", "h", "i"]],
                       [["j", "k", "m"],["l", "n", "o"],["p", "q", "r"]]]
     // 精简写法
     let result = values2.flatMap({ $0 })
     let result2 = result.flatMap({$0})
     print("flatMap:", result, result2)
}

// 自定义实现flatMap
func flatMap_lc<T>(_ transform: (Element) -> [T]) -> [T] {
     var result = [T]()
     for x in self {
         result.append(contentsOf: transform(x))
     }
     return result
}

• filter

// filter: 过滤掉不符合条件的值
func testFilter() {
     let values = [1,2,3,4,5]
     let result = values.filter { (element) -> Bool in
           return element % 2 == 0
     }
     // 精简写法
     let result2 = values.filter({ $0 % 2 == 0})
     let result3 = values.filter_lc({ $0 % 3 == 0})
     print("filter:", result, result2, result3)  // [2, 4]
}

// 自定义实现filter 
// 遍历数组中的每一个元素, 并在闭包中做处理(%2 == 0等), 满足条件则添加到数组中并返回
func filter_lc(_ includeElement: (Element) -> Bool) -> [Element] {
      var result = [Element]()
      for x in self where includeElement(x) {
          result.append(x)
      }
      return result
}

• reduce

func testReduce() {
     let values = [1, 2, 3]
     let initResult = 0    // 初始值
     let result = values.reduce(initResult) { $0 + $1 }   //求和
     let result2 = values.reduce_lc(initResult, combine: +)  // 将 + 作为操作符
     let result3 = values.reduce_lc(initResult) {result,x in result+x}
     print("reduce:", result, result2, result3)
}

// 使用: Int数组中求和,求积, Sting数组中所有元素拼接等
func reduce_lc<T>(_ initial: T, combine: (T,Element) -> T) -> T {
     var result = initial
     for x in self {
         result = combine(result, x)
     }
     return result
}

---

面试题: 求 一个二维Int数组的和?

func sumInt() {
        let values = [[1, 2, 3], [1, 2, 3]]
        let result = values.flatMap { $0 }.reduce(0) {$0 + $1}
        print("sumInt:", result)
}

3. 结语

函数式编程用于像 map 与 lter 这 样的高阶函数进行编程，这只是其中的一个方面. 更多的内容可以去读一读王巍的函数式Swift

如果对文中自定义函数的实现有疑惑, 可以直接参考Demo, 有详细的推倒过程.