Swift高阶函数

2021-09-28 本文已影响0人涂鸦的熊猫

最近在学习Swift，遇到很地方用到Swift高阶函数,所以记录下来

1.filter:过滤/筛选不满足条件的元素，返回满足条件的元素组成数组

 @inlinable public func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]

简述：filter方法参数是一个闭包，闭包返回值是Bool类型，当满足筛选条件的时闭包才有返回值，filter返回值是一个<T>的泛型数组

使用：

let arr = [-1,-10,0,1,10,100]
//打印arr  [-1, -10, 0, 1, 10, 100]
let newArr =  arr.filter {$0>0}
//打印newArr [1, 10, 100]

2.map可以对数组中的每一个元素做一次处理, 返回一个泛型的数组

(1)简单使用：

let arr = [1,2,3]
//打印arr [1,2,3]
let newArr = arr.map{($0*2)}
//打印newArr [2, 4, 6]

(2)常见使用

let arr = ["abc","abcd","abcde","abcdef"]
//打印arr ["abc","abcd","abcde","abcdef"]
let contArr = arr.map{($0.count)}
//打印contArr [3, 4, 5,6]

let arr:[Any?] = [0,1,2,3,4,5,nil,"abc",9,"109"]
//打印arr
//[Optional(0), Optional(1), Optional(2), Optional(3), Optional(4), Optional(5), nil, Optional("abc"), Optional(9), Optional("109")]

let newArr = arr.map { obj -> Int in
    if obj is Int{
        return obj as! Int
    }
    if obj is String{
        return Int(obj as! String) ?? 0
    }
    return 0
}
//打印newArr [0, 1, 2, 3, 4, 5, 0, 0, 9, 109]

注释：
is操作符：若一个类属于另一个类的子类，则会返回true，否则返回false。
as操作符：as（向上转换）、as?（向下转换）、as!（强制解包）
详解可以看看这篇博客我觉着分析的挺好的：https://www.jianshu.com/p/edbdc60218d1

3.reduce 把集合中所有的值结合起来返回一个新的值。

(1)计算数组中数字的和

let arr = [1,2,3,4,5]
//打印arr [1,2,3,4,5]
let sumArr = arr.reduce(0) { partialResult, next in
    return partialResult+next
}
//打印sumArr 15

(2)取出某对象数组中所有元素的某一个属性

struct PackageInfo{
    var name:String
    var number:Int
    var price:Float
    var address:String
}
let testInfo = [
    PackageInfo(name: "测试1", number: 1, price: 1111, address: "阿西西"),
    PackageInfo(name: "测试2", number: 2, price: 882.0, address: "哈哈"),
    PackageInfo(name: "测试3", number: 3, price: 35.0, address: "7哈哈"),
    PackageInfo(name: "测试4", number: 4, price: 50.0, address: "oo")
]
let address =  testInfo.reduce("") { partialResult, packageInfo in
    var str = partialResult
    if partialResult.count > 0{
        str = partialResult + "|"
    }
    str =  str + packageInfo.address
    return str
}
//打印address 阿西西|哈哈|7哈哈|oo

4.compactMap,过滤空值

let arr:[Any?] = [1,2,nil,"12",nil,10]
//打印arr [Optional(1), Optional(2), nil, Optional("12"), nil, Optional(10)]
let newArr = arr.compactMap{($0)}
//打印newArr [1, 2, "12", 10]

5.flatMap:二维数组降维至一维数组

flatMap的闭包接受的是数组的元素，但返回的是一个 SequenceType 类型，也就是另外一个数组
这里与map做一个对比

let numbers = [1, 2, 3, 4, 5]
let result = numbers.map { $0 + 2 }
print(result) // 打印：[3, 4, 5, 6]
result = numbers.flatMap { $0 + 2 } // [3,4,5,6]
let numbersCompound = [[1, 2, 3], [4, 5, 6]]
var res = numbersCompound.map { $0.map{ $0 + 2 } } // [[3, 4, 5], [6, 7, 8]]
var flatRes = numbersCompound.flatMap { $0.map{ $0 + 2 } } // [3, 4, 5, 6, 7, 8]

1.numbersCompound.map { … } 这个调用实际上是遍历了这里两个数组元素 [1,2,3] 和 [4,5,6]。因为这两个元素依然是数组，所以我们可以对他们再次调用 map 函数： $0.map{$ 0 + 2 }。这个内部的调用最终将数组中所有的元素加 2。
2.flatMap 依然会遍历数组的元素，并对这些元素执行闭包中定义的操作。但唯一不同的是，它对最终的结果进行了所谓的 “降维” 操作。本来原始数组是一个二维的，但经过 flatMap 之后，它变成一维的了。

map的定义:

func map (@noescape transform: (Self.Generator.Element) throws -> T) rethrows -> [T]
let stringResult = numbers.map { "No. \($0)" } // // ["No. 1", "No. 2", "No. 3", "No. 4"]

其中闭包为：(Self.Generator.Element) -> T ，Self.Generator.Element类型参数代表数组中当前元素的类型。而T这个返回值是可以和传递进来的值不同，比如我们可以这样：

flatMap的定义:

func flatMap(transform: (Self.Generator.Element) throws -> T?) -> [T]
func flatMap(transform: (Self.Generator.Element) -> S) -> [S.Generator.Element]

和 $\color{purple}{map}$ 不同， $\color{purple}{flatMap}$ 有两个重载。参照我们刚才的示例，我们调用的其实是第二个重载
$\color{purple}{flatMap}$ 的闭包接受的是数组的元素，但返回的是一个 $\color{purple}{SequenceType}$ 类型，也就是另外一个数组。
我们传入给 flatMap 一个闭包$0.map{ $0 + 2 } , 这个闭包中，又对 $0 调用了 map 方法，从 $\color{purple}{map}$ 方法的定义中我们能够知道，它返回的还是一个集合类型，也就是 $\color{purple}{SequenceType}$ 。所以我们这个 $\color{purple}{flatMap}$ 的调用对应的就是第二个重载形式。

总结
$\color{purple}{map}$ ：是对原对象所有元素进行一对一转换处理，中间不会跳过或遗漏，包括nil元素，map 方法接受一个闭包作为参数，然后它会遍历整个 numbers 数组，并对数组中每一个元素执行闭包中定义的操作。相当于对数组中的所有元素做了一个映射。
$\color{purple}{flatMap}$ ：更灵活，可变换维度，也能够自动解包，所以当我们对不符合元素，返回nil，最终的结果是过滤掉nil的，从而能够实现过滤。