阅读 992

Swift里的高阶函数

一. 常见的高级函数简述

函数函数用途说明
sorted排序常用于数组和字典(key/value)的排序
map遍历每一个元素做一次映射操作
flatMap遍历多于用于数组的降维度
compactMap遍历多用于处理数组的可选值
filer过滤对数组元素根据规则过滤一次
reduce多用途基础思想是将一个序列转换为一个不同类型的数据,期间通过一个累加器(Accumulator)来持续记录递增状态

二. 关于闭包的简化

1. 闭包的完整格式
   { (parameters) -> return type in    // 闭包的参数和返回类型
       statements                     // 闭包体
   }
复制代码

2. 闭包简写的依据

  1. 尾随闭包的用法
  • 如果最后一个参数是闭包,可以把闭包放()外面
  • 如果该闭包参数是唯一的参数,那么()可以省略
  1. 闭包的隐式返回

闭包体只有一条执行语句,可以省略return 3. 闭包可根据上下文推断参数和返回值类型 在闭包中,因为包含了上下文的变量和常量的引用,并做了类型推断 4. 简化闭包的参数 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函数

常用于数组或者字典的排序操作。

  1. 数组的操作
        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
        }
复制代码
  1. 字典的操作
        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
        }
复制代码
  1. 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 就能用另外一种方式实现)
  1. 获取数组中最小的值
        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)变量实时记录递增状态(递增并非是指加法),这里是一个整型值。
复制代码
  1. 计算数组元素的加减乘除
        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
复制代码
  1. 倒叙数组
        let arr = [1, 4, 3, 2]
        let result6 = arr.reduce([Int]()) {
            [$1] + $0
        }
        // [2, 3, 4, 1]
复制代码
  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
复制代码
文章分类
iOS
文章标签