Swift - Map

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
    )