Swift5.1学习随笔之Array数组的常见操作

map
map会遍历数组的每个元素，遍历到一个元素，会调用一次闭包生成一个新的值，最终所有的值组成一个新的数组返回

var arr = [1, 2, 3, 4, 5]
var arr1 = arr.map { (i) -> Int in
    return i * 2
}
print(arr1) //[2, 4, 6, 8, 10]

//闭包表达式的简写
var arr1 = arr.map { $0 * 2 }

var arr = arr.map { "rulala_\($0)" }
print(arr) // ["rulala_1", "rulala_2", "rulala_3", "rulala_4", "rulala_5"]

filter
filter会遍历数组的每个元素，如果元素满足一定的条件，就进行筛选过滤，最终筛选结果生成一个新的数组返回

var arr = [1, 2, 3, 4, 5]
var arr2 = arr.filter { (i) -> Bool in
    return i % 2 == 0 // 返回所有偶数
}
print(arr2) //[2, 4]

//闭包表达式的简写
var arr2 = arr.filter { $0 % 2 == 0  }

reduce
reduce 会遍历数组的每个元素，每遍历到一次，就调用一次闭包

@inlinable public func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Self.Element) throws -> Result) rethrows -> Result

reduce的返回值类型是Result，跟参数initialResult一致，说明第一个参数传什么，返回值类型就是什么。nextPartialResult：接受两个参数，返回一个Result类型，nextPartialResult里面第一个参数的初始值就是initialResult的值，第二个参数是数组遍历到的每个元素。
例子里的result + element，就相当于数组每遍历一次，就将上一次的result跟元素element相加，赋值给下一次的result，直到遍历结束：

var arr = [1, 2, 3, 4, 5]
var arr3 = arr.reduce(0) { (result, element) -> Int in
    return result + element
}
print(arr3) //15

//简写
var arr3 = arr.reduce(0) { $0 + $1 }

如果换成result * element，结果就为0

var arr3 = arr.reduce(1) { (result, element) -> Int in
    return result * element
}
print(arr3) //120

flatMap
先看个例子🌰

var arr = [1, 2, 3]

var arr1 = arr.map{ Array.init(repeating: $0, count: $0) }
print(arr1) // [[1], [2, 2], [3, 3, 3]]

var arr2 = arr.flatMap { Array.init(repeating: $0, count: $0) }
print(arr2) // [1, 2, 2, 3, 3, 3]

map跟flatmap一样，最终都是生成一个新的数组返回，但是flatmap的区别是它会将内部的元素都拆开统一生成一个大的数组返回。（flat有平铺的意思，可以这么理解）

flatmap还能把多维数组变成一维数组：

var arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 
var arr1 = arr.map{ $0 }
arr1 // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 
var arr2 = arr.flatMap{ $0 }
arr2 // [1, 2, 3, 4, 5, 6, 7, 8, 9]

compactMap
当闭包中的返回结果是可选的时候，使用compactMap代替flatMap，同时在真正返回结果的时候，会自动过滤掉nil

var arr = [1, nil, 3, nil, 4, .none, Optional(6)]
var arr1 = arr.compactMap { $0 }
print(arr1) // [1, 3, 4, 6]

下面的字符串数组中，分别采用map跟compactMap遍历数组。在map强转失败就是nil，同时强转成功会处理成可选类型；而在compactMap中进行Int强转，不满足强转的元素会被当做nil过滤掉

var  arr = ["123", "test", "jack", "-39"]

var arr1 = arr.map { Int($0) }
print(arr2) // [Optional(123), nil, nil, Optional(-39)]

var arr2 = arr.compactMap { Int($0) }
print(arr2) // [123, -39]