最近在学习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 + 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]
和
不同，
有两个重载。 参照我们刚才的示例， 我们调用的其实是第二个重载
类型，也就是另外一个数组。
我们传入给 flatMap 一个闭包$0.map{ $0 + 2 } , 这个闭包中，又对 $0 调用了 map 方法， 从
总结
：是对原对象所有元素进行一对一转换处理，中间不会跳过或遗漏，包括nil元素，map 方法接受一个闭包作为参数， 然后它会遍历整个 numbers 数组，并对数组中每一个元素执行闭包中定义的操作。 相当于对数组中的所有元素做了一个映射。
：更灵活，可变换维度，也能够自动解包，所以当我们对不符合元素，返回nil，最终的结果是过滤掉nil的，从而能够实现过滤。
