Array - Map(遍历)
var arr = [1,2,3,4]
var arr2 = arr.map { Index in
Index * 2
}
var arr2 = arr.map {
$0 * 2 // 更简洁的方法
}
print(arr2) // [2, 4, 6, 8]
Array - Filter(过滤)
var arr3 = arr.filter { Index in
if Index%2 == 0 {
return true
}else {
return false
}
}
print(arr3) // [2, 4]
var arr3 = arr.filter {
$0 % 2 == 0
}
Array - Reduce
var arr4 = arr.reduce(0) { (partialResult, element) -> Int in
return partialResult + element
}
print(arr4) // 10
var arr5 = arr.reduce(0) {
$0 + $1
}
截屏2022-03-08 下午9.01.16.png
分析上面的图片，map接收一个函数，这个函数，接收一个参数，返回一个泛型，也就是任何类型的基本都可以，我们定义了一个doubleAction函数，可以直接把这个函数放到map的括号里
Map扩展
var arr7 = arr.map {
"abc_\($0)"
}
print(arr7) // ["abc_1", "abc_2", "abc_3", "abc_4"]
map与flatMap
var arr8 = arr.map {
Array.init(repeating: $0, count: $0)
}
print(arr8) // [[1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]
var arr9 = arr.flatMap {
Array.init(repeating: $0, count: $0)
}
print(arr9) // [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
var arrString = ["123","test","jack","-30"]
var arr10 = arrString.map {
Int($0)
}
print(arr10) // [Optional(123), nil, nil, Optional(-30)]
print(arr10.count) // 4
上面这段代码可以看出，转换失败的nil值，也被放入了数组，这并不是我们想要的，而且转换成功的，也变为可选类型了
如果想要解决上面两个问题可以使用compactMap
var arr11 = arrString.compactMap {
Int($0)
}
print(arr11) // [123,-30]
print(arr11.count) // 2
直接帮我们解包了，也把空值清除了，这就很棒棒了
Map优化
var arrTest = [1,2,3]
let result = arr.map {
(i:Int) -> Int in
print("mapping \(i)")
return i*2
}
print("begin-----")
print("mapped",result[0])
print("mapped",result[1])
print("mapped",result[2])
print("end------")
mapping 1
mapping 2
mapping 3
mapping 4
begin-----
mapped 2
mapped 4
mapped 6
end------
留意上面的打印，会发现我还没用到result[0],也就是打印begin---的时候，就已经完成了map的遍历操作了，如果有100个，或者1000个元素呢，而我暂时还不需要用到那么多，或者我只要用到其中的第99个或者第999个呢，怎么去避免这样的一个内存开支呢，我们可以给map加上lazy，直接上代码
var arrTest = [1,2,3]
let result = arr.lazy.map {
(i:Int) -> Int in
print("mapping \(i)")
return i*2
}
print("begin-----")
print("mapped",result[2])
print("end------")
打印结果
begin-----
mapping 3
mapped 6
end------
可以看到就执行了一次，大大提高了效率
Optional的map和flatMap
var num1:Int? = 10
var num2 = num1.map {
$0 * 2
}
print(num2) // Optional(20)
var num3:Int? = nil
var num4 = num3.map {
$0 * 2
}
print(num4) // nil
var fmt = DateFormatter()
fmt.dateFormat = "yyyy-MM-dd"
var dateString:String? = "2011-09-10"
var date1 = dateString != nil ? fmt.date(from: dateString!) : nil
var date2 = dateString.flatMap(fmt.date)
print(date1) //Optional(2011-09-09 16:00:00 +0000)
print(date2) //Optional(2011-09-09 16:00:00 +0000)
var score:Int? = 98
var str1 = score != nil ? "score\(score)" : "No score"
var str2 = score.map { "score\($0)" } ?? "No score"
print(str1) //scoreOptional(98)
print(str2) //score98
firstIndex
var items= [11,22,33]
var index = items.firstIndex { $0 == 22 } // 找到元素等于22的下标
print(index) // 1
为什么叫firstIndex呢，只要找到第一个22的元素，就会停止遍历了，所以叫firstIndex（第一个下标）
扩展
在一个数组中，里面存放了若干个Person的实例，如果找到想要的那一个Person实例对象
struct Person {
var name:string
var age:Int
}
var items = [
Person(name:"jack",age:20),
Person(name:"rose",age:30),
Person(name:"kate",age:40),
]
func gePerson1(_ name:String) -> Person? {
let index = items.firstIndex { $0.name == name }
return index != nil ? itmes[index!] : nil
}
func getPerson2(_ name:String) -> Person?{
return items.firstIndex { $0.name == name }.map { items[$0] }
}
扩展2
struct Person {
var name:String
var age:Int
init?(_ dict:[String:Any]) {
guard let name = dict["name"] as? String,
let age = dict["age"] as? Int else {
return nil
}
self.age = age
self.name = name
}
}
var json:Dictionary? = ["name":"jack","age":10]
var p1 = json != nil ? Person.init(json!) : nil
var p2 = json.flatMap {
Person.init($0)
}
var p3 = json.flatMap (
Person.init
)
