swift进阶(一) - 高阶函数(map,flatMap,reduce,fliter)

前言:swift是一门很优雅,很简洁,功能很强大的语言,同时也是一门很复杂的语言。进门比较简单,看完苹果官方的文档就可以基本入门,进阶很难,很多比较好用的特性需要深入探索。

1.高阶函数

在Wikipedia中定义,高级函数至少满足下面一个条件:

  • 接收一个或者多个函数作为传入参数
  • 把函数作为返回结果

举个例子:

func higherOrderFunction(str: String, argument: ((String) -> String)) -> String {
    return argument(str)
}
let result = higherOrderFunction(str: "hello world!", argument: {$0})   
//hello world!
//接收一个传入值和返回值都为字符串的函数为参数,返回一个字符串位结果

2.基本使用

  • ** Map**

map接收一个闭包作为参数,然后遍历整个数组,执行闭包里面的操作,可以看作对数组里所有的元素做了一个映射,返回来的是一个数组。

举个例子:

let numbers = [1, 2, 3, 4, 5, 6, 7, 8]
let result = numbers.map{$0+2}  //[3, 4, 5, 6, 7, 8, 9, 10]

先来看一下map的定义:

func map(_ transform: (Element) throws -> T) rethrows -> [T]

去掉无关的修饰词:

func map(_ transform: (Element) -> T) -> [T]

可以看出来map接收了一个闭包transform为参数,闭包参数是Element代表数组里的一个元素,返回值是一个范型,和传入参数类型无关,并且闭包的返回值和map函数的返回值是同一类型,都是范型T,也就是说map可以返回和数组元素不一样类型的值
举个例子:

let numbers = [1, 2, 3, 4, 5, 6, 7, 8]
let result = numbers.map{"No.\($0)"}  //["No.1", "No.2", "No.3", "No.4", "No.5", "No.6", "No.7", "No.8"]

再进一步,我们去看一下map的源码实现:

  @_inlineable
  public func map(
    _ transform: (Iterator.Element) throws -> T
  ) rethrows -> [T] {
    // TODO: swift-3-indexing-model - review the following
    let count: Int = numericCast(self.count)
    if count == 0 {
      return []
    }

    var result = ContiguousArray()
    result.reserveCapacity(count)

    var i = self.startIndex

    for _ in 0..

最重要的代码

var result = ContiguousArray()
for _ in 0..

新生成一个数组,数组里面填充闭包操作后的返回值,最后返回该数组。所以,map高阶函数适合一些需要对整个数组元素做一些额外操作的需求。

  • flatMap

flatMap函数和map函数实现的功能差不多,差别在于,flatMap有两个重载,一个强制解包去掉数组中nil元素,一个将二维数组降为一位数组。

(1). 遍历数组:

let numbers = [1, 2, 3, 4, 5, 6, 7, 8]
let result = numbers.flatMap{$0}  //[1, 2, 3, 4, 5, 6, 7, 8]

(2).数组降维

let numbers = [[1, 2, 3, 4], [5, 6, 7, 8]] 
let result = numbers.flatMap{$0}  //[1, 2, 3, 4, 5, 6, 7, 8]
let result2 = numbers.map{$0}  //[[1, 2, 3, 4], [5, 6, 7, 8]]

(3).去掉数组中nil

let numbers = [1, 2, 3, 4, nil]    //[Optional(1), Optional(2), Optional(3), Optional(4), nil]
let result = numbers.flatMap{$0}  //[1, 2, 3, 4]去掉nil,解包输出
let result = numbers.map{$0}  //[Optional(1), Optional(2), Optional(3), Optional(4), nil]

注意:

//非二维数组,数组不能和非数组合并
let numbers = [1, 2, 3, 4, [5, 6]] as [Any]   //[1, 2, 3, 4, [5, 6]]
let result = numbers.flatMap{$0}  //[1, 2, 3, 4, [5, 6]]
let result2 = numbers.map{$0}  //[1, 2, 3, 4, [5, 6]]

//数组中的数组包含nil值,因为并不是数组和数组的操作,元素不会合并成一个数组,所以,数组中的数组不会被遍历,原样输出
let numbers = [1, 2, 3, 4, [5, 6, nil]] as [Any]   //[1, 2, 3, 4, [Optional(5), Optional(6), nil]]
let result = numbers.flatMap{$0}  //[1, 2, 3, 4, [Optional(5), Optional(6), nil]]

//因为数组元素其中一个为nil,去掉nil,解包输出
let numbers = [[1, 2, 3, 4], [5, 6], nil]  //[Optional([1, 2, 3, 4]), Optional([5, 6]), nil]
let result = numbers.flatMap{$0}  //[[1, 2, 3, 4], [5, 6]]

//数组包含两个数组和一个nil,去掉nil,解除最外层包输出
let numbers = [[1, 2, 3, 4], [5, 6, nil], nil]   //[Optional([Optional(1), Optional(2), Optional(3), Optional(4)]), Optional([Optional(5), Optional(6), nil]), nil]
let result = numbers.flatMap{$0}  //[[Optional(1), Optional(2), Optional(3), Optional(4)], [Optional(5), Optional(6), nil]]

//数组和数组合并
let numbers = [[1, 2], [3, 4, nil]]   //[[Optional(1), Optional(2)], [Optional(3), Optional(4), nil]]
let result = numbers.flatMap{$0}  //[Optional(1), Optional(2), Optional(3), Optional(4), nil]

由上面的例子,引出三个问题:
1.怎么去掉nil
2.怎么强行解包
3.如何将二维数组降维

先看一下flatMap的定义:

func flatMap(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
func flatMap(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

去掉不相关的修饰词:

func flatMap(_ transform: (Element) -> SegmentOfResult) -> [SegmentOfResult.Iterator.Element]
func flatMap(_ transform: (Element) -> ElementOfResult?) -> [ElementOfResult]

第二个重载接收的闭包返回值是可选类型(Optional),猜测去掉数组中的nil和解包操作都在这个重载;第一个重载接收闭包返回的是Sequence类型,可以把它看作是数组,那么二维数组降维应该调的是第一个重载,具体是不是正确的,继续深入看flatMap的源码实现:

flatMap第一个重载

  @_inlineable
  public func flatMap(
    _ transform: (${GElement}) throws -> SegmentOfResult
  ) rethrows -> [SegmentOfResult.${GElement}] {
    var result: [SegmentOfResult.${GElement}] = []
    for element in self {
      result.append(contentsOf: try transform(element))
    }
    return result
  }

flatMap接收的闭包返回值是Sequence,可以看成数组。重点代码:

result.append(contentsOf: try transform(element))

这个函数有什么作用呢?这个函数的作用就是把element数组里面的元素逐个取出来,然后添加到result数组的后面,这就是flatMap可以将二维数组降维成一维数组的原因,函数描述:

Adds the elements of a sequence to the end of the array.

举个例子:

var nums1 = [1, 2, 3, 4]
let nums2 = [5, 6, 7, 8, 9]
nums1.append(contentsOf: nums2)  //[1, 2, 3, 4, 5, 6, 7 ,8, 9]

flatMap第二个重载

  @_inlineable
  public func flatMap(
    _ transform: (${GElement}) throws -> ElementOfResult?
  ) rethrows -> [ElementOfResult] {
    var result: [ElementOfResult] = []
    for element in self {
      if let newElement = try transform(element) {
        result.append(newElement)
      }
    }
    return result
  }

flatMap接收的闭包返回值是可选类型(Optional),看一下关键代码:

for element in self {
  if let newElement = try transform(element) {
    result.append(newElement)
  }
}

element就是数组里的每一个元素,"let newElement = transform(element)",关键的一段代码,let常量不能为nil,所以,当transform(element)=nil,就被过滤掉了,并且newElement不是可选类型,所以,这里会解包赋值。

  • reduce

Returns the result of combining the elements of the sequence using the given closure.

简单点来说就是联合处理数组的每个元素,举个例子求和:

let numbers =  [1, 2, 3, 4, 5]
let sum = numbers.reduce(0, {$0+$1})  //15
//0是输入的初始值,$0,$1分别是闭包的第一个参数和第二个参数

不一定要求和,比如生成字符串:

let numbers =  [1, 2, 3, 4, 5]
let sum = numbers.reduce("", {"\($0)\($1)"})  //"12345"

废话不多说,直接上源码:

  @_inlineable
  public func reduce(
    _ initialResult: Result,
    _ nextPartialResult:
      (_ partialResult: Result, ${GElement}) throws -> Result
  ) rethrows -> Result {
    var accumulator = initialResult
    for element in self {
      accumulator = try nextPartialResult(accumulator, element)
    }
    return accumulator
  }

新生成一个变量accumulator,每次执行完闭包都把值赋给accumulator。闭包传进去的参数为上一次的值和当前数组元素,所以,我们可以将整个数组的值累加起来。

  • filter

Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.

简单来说就是从一个数组筛选出符合条件的元素,以数组的形式返回。举个例子,筛选出<3的元素:

let numbers =  [1, 2, 3, 4, 5]
let sum = numbers.filter{$0<3} //[1, 2]

3.总结

刚开始学习这些高阶函数,还挺难懂的,但是一旦懂了,就如虎添翼,用起来非常爽。

参考
Swift 烧脑体操(三) - 高阶函数
谈谈 Swift 中的 map 和 flatMap
Higher Order Functions: Map, Filter, Reduce and more

你可能感兴趣的:(swift进阶(一) - 高阶函数(map,flatMap,reduce,fliter))