一. 常见的高级函数简述
| 函数 | 函数用途 | 说明 |
|---|---|---|
| sorted | 排序 | 常用于数组和字典(key/value)的排序 |
| map | 遍历 | 每一个元素做一次映射操作 |
| flatMap | 遍历 | 多于用于数组的降维度 |
| compactMap | 遍历 | 多用于处理数组的可选值 |
| filer | 过滤 | 对数组元素根据规则过滤一次 |
| reduce | 多用途 | 基础思想是将一个序列转换为一个不同类型的数据，期间通过一个累加器（Accumulator）来持续记录递增状态 |
二. 关于闭包的简化
1. 闭包的完整格式
{ (parameters) -> return type in // 闭包的参数和返回类型
statements // 闭包体
}
2. 闭包简写的依据
- 尾随闭包的用法
- 如果最后一个参数是闭包，可以把闭包放
()外面 - 如果该闭包参数是唯一的参数，那么
()可以省略
- 闭包的隐式返回
闭包体只有一条执行语句,可以省略
return - 闭包可根据上下文推断参数和返回值类型 在闭包中，因为包含了上下文的变量和常量的引用，并做了类型推断
- 简化闭包的参数 Swift自动为内联闭包提供简写参数名称，用$0(从0开始，表示第i个参数...)
例子说明
let arr = [2, 1, 3]
/// 完整的sorted的写法
let result = arr.sorted (by: { (a: Int, b: Int) -> Bool in
return a < b
})
// 如果传入的参数，最后一个参数是闭包，那么可以把闭包放在（）外面
let _ = arr.sorted() { (a: Int, b: Int) -> Bool in
return a < b
}
// 如果传入的参数只有一个，且是一个闭包，那么这个（）可以省略
let _ = arr.sorted { (a: Int, b: Int) -> Bool in
return a < b
}
// 从单行表达式闭包中隐式返回（闭包体只有一行代码，可以省略return）
let _ = arr.sorted { (a: Int, b: Int) -> Bool in
a < b
}
// 闭包可更具上下文推断参数和返回值的类型
let _ = arr.sorted { (a, b) -> Bool in
a < b
}
// 简化闭包的参数名.使用简化参数名，in和之前的描述可以省略
let _ = arr.sorted {
$0 < $1
}
三. sorted函数
常用于数组或者字典的排序操作。
- 数组的操作
let arr = [2, 1, 3]
/// 数组降序排序
let result = arr.sorted { (a, b) -> Bool in
return a < b
}
/// 数组升序排序
let result1 = arr.sorted { (a, b) -> Bool in
return a > b
}
- 字典的操作
let dict = [ "2": "b", "1": "a", "3": "c", ]
/// 字典key排序
let result2 = dict.sorted { (a, b) -> Bool in
return a.key < b.key
}
/// 字典value排序
let result3 = dict.sorted { (a, b) -> Bool in
return a.value < b.value
}
- sorted函数的简化
// 默认从小到大排序
let _ = arr.sorted()
// 从小到大排序
let _ = arr.sorted(by: <)
// 从大到小排序
let _ = arr.sorted(by: >)
四. map函数
map: 映射
1. 说明
- 可以对数组中的每一个元素做一次映射操作。
- map函数返回一个新的数组，并且数组的类型不要求和原数组类型一致。
2. 示例
- 对数组的每一个元素都乘以2一次.
let arr = [1,2,3]
let doubleD = arr.map {
$0 * 2
}
doubleD的结果为 : [2, 4, 6]
- 获取的数组类型跟入参数组类型无关
let mapArr = ["Swift","Objc","Flutter"]
let mapEndArr = mapArr.map {
$0.count
}
mapEndArr的结果为： [5, 4, 7]
- 返回值中允许nil的存在
let opArr = ["1","2",nil,"3"]
let opMapArr = opArr.map {
$0
}
opMapArr结果为: [Optional("1"), Optional("2"), nil, Optional("3")]
五. flatMap 函数
flat: 使变平
1. flatMap还能把数组中存有数组的数组（二维数组、N维数组）一同打开变成一个新的数组
let arr3 = [[1, 2, 3], [4, 5, 6]]
let result = arr3.flatMap {
$0
}
let result2 = arr3.flatMap {
$0.map {
$0 + 2
}
}
result的值： [1, 2, 3, 4, 5, 6]
result2的值： [3, 4, 5, 6, 7, 8]
2. flatMap也能把两个不同的数组合并成一个数组，这个合并的数组元素个数是前面两个数组元素个数的乘积
let fruits = ["Apple", "Orange", "Puple"]
let counts = [2, 3, 5]
let array = counts.flatMap { count in
fruits.map ({ fruit in
return fruit + " \(count)"
})
}
array的结果 ["Apple 2", "Orange 2", "Puple 2", "Apple 3", "Orange 3", "Puple 3", "Apple 5", "Orange 5", "Puple 5"]
六. compactMap函数
compact: 把……压实；使简洁；使紧密，压缩
compactMap，可以把一个集合中的空值去除，并且返回一个去除nil值得数组
- 过滤
// 过滤nil，并解包返回值
let arr = [1, 5, nil, 4]
let result = arr.compactMap {
$0
}
// arr的结果：[1, 5, 4]
- 类型转换
// 类型转换 [Int] -> [String]
let arr1 = [1, 5, 4]
let result1 = arr1.compactMap {
String($0)
}
// arr1的结果：["1", "5", "4"]
- 筛选数据
let arr3 = [1, 2, 3, 4, 5, 6, 7, 8]
let result3 = arr3.compactMap {
$0 % 4 == 0 ? $0 : nil
}
//arr3结果： [4, 8]
结果可以看出，虽然闭包的返回值是可选的，但是这个函数的返回值结果并不是可选的。
七. filer函数
file: 过滤。 filer: 过滤器
filer过滤函数，可以过滤掉数组中不满足筛选条件的元素，返回满足筛选条件的元素所组成的数组。
- 筛选出元素 大于 3的元素，并返回集合
let arr = [1, 2, 3, 4, 5]
let result = arr.filter {
$0 > 3
}
// result的结果： [4, 5]
- 筛选出字符串的长度小于10的字符串
let arr2 = ["Objective-C", "Swift", "HTML", "CSS", "JavaScript"]
let result2 = arr2.filter {
$0.count < 10
}
// result的结果 ["Swift", "HTML", "CSS"]
- 换种写法
// 定义筛选规则函数
func stringCountLessTen(str: String) -> Bool {
return str.count < 10
}
let result2 = arr2.filter(stringCountLessTen(str:))
八. reduce 函数
func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
initialResult 为初始值，Element 是要处理的元素，处理后返回Result 作为下次闭包的参数。
- reduce 的基础思想是将一个序列转换为一个不同类型的数据，期间通过一个累加器（Accumulator）来持续记录递增状态。为了实现这个方法，我们会向 reduce 方法中传入一个用于处理序列中每个元素的结合（Combinator）闭包 / 函数 / 方法。
- reduce 是 map、flatMap 或 filter 的一种扩展的形式（后三个函数能干嘛，reduce 就能用另外一种方式实现)
- 获取数组中最小的值
let arr = [1, 4, 3, 2]
// 获取数组中的最小值
let result = arr.reduce(Int.max, min)
func combinator(accumulator: Int, current: Int) -> Int {
return accumulator + current
}
[1, 2, 3].reduce(0, combine: combinator)
// 执行步骤如下
combinator(0, 1) { return 0 + 1 } = 1
combinator(1, 2) { return 1 + 2 } = 3
combinator(3, 3) { return 3 + 3 } = 6
结果为 6
[1,2,3] 中的每个元素都将调用一次结合（Combinator）函数进行处理。同时我们使用累加器（Accumulator）变量实时记录递增状态（递增并非是指加法），这里是一个整型值。
- 计算数组元素的加减乘除
let arr = [1, 4, 3, 2]
let result2 = arr.reduce(0, +)
let result3 = arr.reduce(0, -)
let result4 = arr.reduce(1, *)
let result5 = arr.reduce(1, /)
// 分别为 10 -10 24 0
- 倒叙数组
let arr = [1, 4, 3, 2]
let result6 = arr.reduce([Int]()) {
[$1] + $0
}
// [2, 3, 4, 1]
- 多维度的数据处理
// 计算出位于台湾省的人数，以及平均年龄
let users: [[String: Any]] = [
["name": "小明", "pro": "山东", "age": 10],
["name": "小花", "pro": "上海", "age": 30],
["name": "小任", "pro": "台湾", "age": 5],
["name": "小爱", "pro": "台湾", "age": 5],
["name": "小李", "age": 10] // 没有录入省份
]
// 定义一个别名为ProvinceTuples元组，记录位于台湾省的人数（count）和 总年龄（age）
typealias ProvinceTuples = (count: Int, age: Int)
let result = users.reduce((0, 0)) { (province: ProvinceTuples, user) -> ProvinceTuples in
// 满足条件 (能获取到年龄， 能获取到省并且省是台湾)
// Swift3时if let和guard场景的where已经被Swift4的逗号取代
if let pro = user["pro"] as? String, pro == "台湾",
let age = user["age"] as? Int
{
return (count: province.count + 1, age: province.age + age)
} else { // 不满足条件
// 此时的province为（0， 0）
return province
}
}
let count = result.0
let age = Float(result.1) / Float(count)
// count 为2， age为5.0
