【《Pro Swift》阅读笔记】07 - 函数式编程

书籍链接：《Pro Swift》 (链接需要梯子才能打得开)。

函数式编程是一个很大的话题，在此不详细描述。大家可以自行了解。在这一章节我们主要看看函数式编程在Swift中的应用。

为了更好的理解函数式编程的好处，我们先看看这个五个原则：

  • 函数在Swift中属于一等数据类型，就像整型和字符串一样，函数也可以被创建、复制和传递。
  • 函数可以作为参数传入另外一个函数。
  • 为了让函数可以重用，传入一样的参数，应该返回一样的结果，并且不会产生任何副作用。
  • 优先使用不可变的数据类型，尽量不要使用函数来改变可变的变量。
  • 因为函数不产生副作用，并且变量是不可变的，所以在函数里面尽可能减少程序中跟踪的状态。

一、函数式编程在Swift中的应用

1. map

定义：把容器中的元素取出，然后放到closure中运行，最后把返回的结果放到一个新的容器中。Swift中的数组、字典和集合都有这个方法。

多看几个例子：

// 转换成大写
let fruits = ["Apple", "Cherry", "Orange", "Pineapple"]
let upperFruits = fruits.map { $0.uppercased() }

// 转换成对分数的描述
let scores = [100, 80, 85]
let formatted = scores.map { "Your score was \($0)" }

// 转换成对分数的是否通过
let scores = [100, 80, 85]
let passOrFail = scores.map { $0 > 85 ? "Pass" : "Fail" }

// 转换成是否在范围内
let position = [50, 60, 40]
let averageResults = position.map { 45...55 ~= $0  ? "Within average" : "Outside average" }

// 求平方根
let numbers: [Double] = [4, 9, 25, 36, 49]
let result = numbers.map(sqrt)

其实这些方法我们都可以使用for循环完成，但是使用map()会更简洁些。要注意的是: map()会遍历每个元素，而在for循环中，我们可以控制是否break。

2. Optional map

我们刚刚说了对map()的定义是把容器中的元素取出，然后放到closure中运行，最后把返回的结果放到一个新的容器中。因为Optional也是属于容器，只有一个元素的容器，所以我们也可以在Optional类型中使用map():

let i: Int? = 10
let j = i.map { $0 * 2 }
print(j) // Optional(20)

如果i是nil，那么map()返回nil。

我们再看一个例子：

func fetchUsername(id: Int) -> String? {
    if id == 1989 {
        return "Taylor Swift"
    } else{
        return nil
    }
}

我们来使用上面的方法：

// 如果不使用map
let username = fetchUsername(id: 1989)
let formattedUsername = username != nil ? "Welcome, \(username!)!" : "Unknown user"
print(formattedUsername)

// 使用map
var username: String? = fetchUsername(id: 1989)
let formattedUsername = username.map { "Welcome, \($0)!" } ?? "Unknown user"
print(formattedUsername)

可以看到，不使用map()的话，要先判断username是否为nil，如果不为nil，还要进行强制unwrap；而使用map则简单很多。

3. forEach

map()和forEach()很类似，都是会遍历容器中的每一个元素；不同之处在于，1）map()会返回新的容器，而forEach()返回空，2）forEach()在执行的时候，是按照数组元素的顺序执行的；而为了提高性能，map()是没有顺序的。

例子：

["Taylor", "Paul", "Adele"].forEach { print($0) }

forEach()的内部实现实际是使用了for循环：

public func forEach(_ body: (Iterator.Element) throws -> Void) rethrows {
    for element in self {
        try body(element)
    }
}

4. flatMap

先来看一个map()的例子：

let albums: [String?] = ["Fearless", nil, "Speak Now", nil, "Red"]
let result = albums.map { $0 }
print(result)
//  [Optional("Fearless"), nil, Optional("Speak Now"), nil, Optional("Red")]

因为albums的元素类型是String?，在map()直接返回$0，所以得到的result全是Optional类型。

但是如果我们使用flatMap()的话：

let albums: [String?] = ["Fearless", nil, "Speak Now", nil, "Red"]
let result = albums.flatMap { $0 }
print(result)
// ["Fearless", "Speak Now", "Red"]

result变成了[String]类型，所有Optional和nil都去掉了。

我们再看另外一个例子：

let labels = view.subviews.flatMap { $0 as? UILabel }

上面这行代码的作用：把subviews中属于UILabel类型的找出来，并转成UILabel。

所以说我们可以对flatMap()这么理解：，先用map()把一个容器变成另外一个容器，然后再把nil去掉。

4. filter()

filter()是比较容易理解的，就是把符合我们传入的closure条件的元素找出来，然后组成一个新的容器。

例如下面的例子，把偶数找出来：

let fibonacciNumbers = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
let evenFibonacci = fibonacciNumbers.filter { $0 % 2 == 0 }

4. reduce()

reduce()把容器的所有元素，根据我们传入的closure，最终合并成一个值。这个函数需要两个变量，第一个是初始值，第二个是closure。

例如下面的例子，求数组元素的和：

let numbers = [1, 2, 3, 4]
let numberSum = numbers.reduce(0, { sum, number in
    return sum + number
})
// numberSum == 10

当numbers.reduce在运行的时候，最开始的求和结果是我们传入的0，然后用第一个元素1放到closure运行，这时sum是0，number就是第一个元素1，所以结果就是0 + 1；然后用第二个元素2放到closure运行，这时sum就是上次的运算结果1，number就是第二个元素2，结果就是1 + 2；以此类推，最后结果是10。

我们还可以简写成，因为+本身是一个实现了加法的方法，而方法可以看作是closure作为参数：

let numbers = [1, 2, 3, 4]
let numberSum = numbers.reduce(0, +)
1) 使用reduce()返回一个Bool类型的值

有时候我们可能会遇到这种情况：判断数组内的元素是否都满足某个条件。这时我们用reduce()就可以轻松实现。

例如，判断一组人名的长度是否都大于4：

let names = ["Taylor", "Paul", "Adele"]
let longEnough = names.reduce(true) { $0 && $1.count > 4 }
print(longEnough)

最终返回false。

不过要注意的是，如果数组中有1000个人名，在第二个元素就已经不满足条件，就没必要再判断下去了。如果使用reduce()的话，就不管是否已经有不满足条件的元素，都会遍历完所有元素，会做一些无用功。所以在实际开发中，我觉得还是优先使用这个方法，如果确实会影响性能，在考虑其他办法。

2) 使用reduce()查找一个值

例如，查找一组人名中最长的名字：

let names = ["Taylor", "Paul", "Adele"]
let longest = names.reduce("") { $1.count > $0.count ? $1 : $0 }

但是我们也可以使用max():

let longest = names.max { $1.count > $0.count }

这个例子中，reduce()会多做一次比较，因为我们给了一个初始值；而max()返回一个Optional类型。实际开发中我们可以根据情况，选择一个比较好的方案。

5. sort()

如果数组中存储的是基本数据类型，例如字符串和数字类型，我们可以直接用没有参数的sort()（默认是从小到大排序的）：

let scoresString = ["100", "95", "85", "90", "100"]
let sortedString = scoresString.sorted()
print(sortedString)
// ["100", "100", "85", "90", "95"]

因为scoresString是字符串数组，所以Swift根据字符串的每一个字符从小到大排列，就造成了这个结果：["100", "100", "85", "90", "95"]。但事实上这不是我们想要的结果，因为从常识来说，100肯定是最大的。所以我们要先把他转为数字类型的数组：

let scoresInt = scoresString.flatMap { Int($0) }
let sortedInt = scoresInt.sorted()
print(sortedInt)

我们使用了flatMap()把[String]转为[Int]，如果是用map()的话，就会转成[Int?]，不方便我们后续使用，因为[Int?]是没有sort()方法的，[Int]才有。

如果我们使用map()的话，需要使用有closure参数的sort()，代码会多很多：

let scoresInt = scoresString.map { Int($0) }
let sortedInt = scoresInt.sorted {
    if let unwrappedFirst = $0, let unwrappedSecond = $1 {
        return unwrappedFirst < unwrappedSecond
    } else {
        return false
    }
}
1) 对复杂的数据排序

如果我们的数组元素类型是自定义的类型，例如struct类型，并且有不同的属性，这种情况下，我们要告诉Swift如何进行排序。有以下两种方式：

  • 使用有参数的sort()
  • 实现Comparable协议后，使用没有参数的sort()

我们举个例子，有一个Person结构：

struct Person {
   var name: String
   var age: Int
}

let taylor = Person(name: "Taylor", age: 26)
let paul = Person(name: "Paul", age: 36)
let justin = Person(name: "Justin", age: 22)
let adele = Person(name: "Adele", age: 27)

let people = [taylor, paul, justin, adele]

使用第一种方法排序：

let sortedPeople = people.sorted { $0.name < $1.name }

但是我们更推荐使用第二种方法：实现Comparable协议，因为这可以让排序的逻辑更集中。如果我们要在多个地方进行排序，使用sort()即可，不需要多次调用有参数的sort()：

struct Person: Comparable {
    var name: String
    var age: Int

    static func <(lhs: Person, rhs: Person) -> Bool {
        return lhs.name < rhs.name
    }

    static func ==(lhs: Person, rhs: Person) -> Bool {
        return lhs.name == rhs.name && lhs.age == rhs.age
    }
}

我们就可以直接调用无参数的sort()进行排序：

let sortedPeople = people.sort()

另外Comparable是继承于Equatable的，所以我们也同时解决了比较的问题。

2) 反向排序

如果我们使用有参数的sort()，直接把<改为>即可：

let sortedString = scoresString.sorted {
    if let first = Int($0), let second = Int($1) {
        return first > second
    } else {
        return false
    }
}
print(sortedString)

Swift还有一个自带的reversed()方法：

let names = ["Taylor", "Paul", "Adele", "Justin"]

let sorted = names.sorted().reversed()
print(sorted)

上面的sorted等于ReverseRandomAccessCollection<Array<String>>(_base: ["Adele", "Justin", "Paul", "Taylor"])，他其实是一个lazy数组，存储了原来的数组和reverse函数。因为数组是一个值类型，所以Swift不必真实的把原来的数组反向排序。如果我们想要一个真实的数组，需要通过Array的初始化函数来创建：

let sortedArray = Array(names.sorted().reversed())
print(sortedArray)

6. 函数连续调用

也就是说多个函数连在一起调用。例如下面的例子：

let london = (name: "London", continent: "Europe", population: 8_539_000)
let paris = (name: "Paris", continent: "Europe", population: 2_244_000)
let lisbon = (name: "Lisbon", continent: "Europe", population: 530_000)
let rome = (name: "Rome", continent: "Europe", population: 2_627_000)
let tokyo = (name: "Tokyo", continent: "Asia", population: 13_350_000)

let cities = [london, paris, lisbon, rome, tokyo]

let biggestCities = cities
    .filter { $0.population > 2_000_000 }
    .sorted { $0.population > $1.population }
    .prefix(upTo: 3)
    .map { "\($0.name) is a big city, with a population of \($0.population)" }
    .joined(separator: "\n")

print(biggestCities)

// Tokyo is a big city, with a population of 13350000
// London is a big city, with a population of 8539000
// Rome is a big city, with a population of 2627000

先用filter()找出人口大于2_000_000（_是为了让读者更好的读这个数）；再用sorted()从大到小排序，再用prefix()取出前三个，再用map()转换成对这个城市的描述，最后用joined()把他们结合在一起，成为一个字符串。

上面这种多个方法连在一起的写法，在RxSwift中无处不在。

7. 复合函数

有时候我们开发过程中，可能会遇到这样的情况：

let foo = functionC(functionB(functionA()))

为了让代码更好看些，可能会改成这个样子：

let a = functionA()
let b = functionB(a)
let foo = functionC(b)

现在我们用另外一种更好的方式来解决这个问题，自定义一个运算符>>>，最终把代码改写成：

let foo = functionA >>> functionB >>> functionC

关于运算符的问题，在【《Pro Swift》阅读笔记】05 - 方法有讲到，大家可以先去看看这个。

下面看看如何自定义运算符>>>:

precedencegroup CompositionPrecedence {
    associativity: left
}

infix operator >>>: CompositionPrecedence

func >>> <T, U, V>(lhs: @escaping (T) -> U, rhs: @escaping (U) -> V) -> (T) -> V {
    return { rhs(lhs($0)) }
}

我们用到了三个泛型：T、U和V，需要两个方法类型的操作数lhs和rhs，其中lhs接受T类型的参数并返回U类型，rhs接受U类型的参数并返回V类型。整个运算符返回一个方法类型：接受T类型的参数并返回V类型，所以方法的实现是return { rhs(lhs($0)) }。另外，因为两个closure不是马上调用，所以都要用@escaping。

下面我来看一个实际的例子，先生成一个随机的Int，再求这个随机数的所有因子并组成数组，最后把所以因子组成一个String：

func generateRandomNumber(max: Int) -> Int {
   let number = Int(arc4random_uniform(UInt32(max)))
   print("Using number: \(number)")
   return number
}

func calculateFactors(number: Int) -> [Int] {
   return (1...number).filter { number % $0 == 0 }
}

func reduceToString(numbers: [Int]) -> String {
   return numbers.reduce("Factors: ") { $0 + String($1) + " " }
}

如果我们用之前的方法，会这么做：

let result = reduceToString(numbers: calculateFactors(number: generateRandomNumber(max: 100)))
print(result)

如果是使用>>>运算符：

let combined = generateRandomNumber >>> calculateFactors >>> reduceToString
print(combined(100))

明显使用>>>运算符会更清晰易读：生成随机数；计算因子；生成字符串。而且我们合并好的方法combined可以重复使用。另外我们还可以用>>>拼接更多的方法。

8. lazy方法

在有些方法调用的时候，我们也可以使用lazy:

使用lazy

因为我们使用了lazy，当我们调用前两个print的时候，Swift才会去执行filter()，filter()的closure调用了2万次，每个print调用1万。因为lazyFilter只有在numbers的每个元素都处理完成之后才能确定下来，而后面两个print，当我们访问lazyMap[5000]时，才会去运行map()，并且只运行一次，其他没有访问的会忽略。

如果不使用lazy的情况如下：

不使用lazy

如果不使用lazy，lazyFilter和lazyMap在创建的时候就会去执行filter()和map()，所有他们的closure都是运行1万次。后面再print的时候就不会调用filter()和map()了，因为lazyFilter和lazyMap在前面已经创建好了。

是否要使用lazy，我们要根据实际情况来看。

二、函子和单子

在这里简单介绍下函子和单子的概念。

函子：实现了map()方法的容器。也不一定要把这个方法称为map()，只要这个方法实现了把A容器转换成B容器。我们经常用的数组和Optional都是函子。

单子：实现了flatMap()的函子，也就是同时实现了map()和flatMap()的容器。数组和Optional也都是单子。

完

有任何问题，欢迎大家留言！

欢迎加入我管理的Swift开发群：536353151，本群只讨论Swift相关内容。

原创文章，转载请注明出处。谢谢！

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 214,444评论 6赞 496
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 91,421评论 3赞 389
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 160,036评论 0赞 349
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,363评论 1赞 288
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,460评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,502评论 1赞 292
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,511评论 3赞 412
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,280评论 0赞 270
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,736评论 1赞 307
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,014评论 2赞 328
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,190评论 1赞 342
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,848评论 5赞 338
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,531评论 3赞 322
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,159评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,411评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,067评论 2赞 365
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,078评论 2赞 352