//一、Array的使用
func  arrayUse() -> Void {
    //1、 Array的常见操作 - map(映射)
    do{
        print("------1-----")
       
        let intArr = [1,2,3,4]
        print(intArr)//[1, 2, 3, 4]
        
        /**
         1、映射
         @inlinable public func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
         */
        let intArr2 = intArr.map{ (item:Int) -> Int in
            return item * 2
        }
        print(intArr2)//[2, 4, 6, 8]
        
        
        //2、简写
        let intArr3 = intArr.map { $0 * 2}
        print(intArr3)//[2, 4, 6, 8]
        
        
        //3、传入一个函数
        func makeDouble(num:Int) -> Int {
            num * 2
        }
        let intArr4 = intArr.map(makeDouble(num:))
        print(intArr4)//[2, 4, 6, 8]
        
        
        //4、
        let strArr = ["12","34","56"]
        print(strArr)//["12", "34", "56"]
        let strArr2 = strArr.map { (item:String) -> Int in
            Int(item)!
        }
        print(strArr2)//[12, 34, 56]
    }
    
    
    //2、 Array的常见操作 - filter(过滤器)
    do{
        print("-------2------")
        
        let arr = [1, 2, 3, 4]
        print(arr)//[1, 2, 3, 4]
        
        /**
         1、过滤器，符合条件的放入数组
         func filter(_ isIncluded: (Int) throws -> Bool) rethrows -> [Int]
         */
        let arr1 = arr.filter {(item:Int) -> Bool in
            item % 2 == 0
        }
        print(arr1)//[2, 4]
        
        
        //2、简写
        let arr2 = arr.filter { $0%2 == 0}
        print(arr2)//[2, 4]
        
        
        //3、传入一个函数
        func isEvenNumber(num:Int) -> Bool{ num % 2 == 0 }
        let arr3 = arr.filter(isEvenNumber)
        print(arr3)//[2, 4]
        
        
        //4、
        let strArr  = ["121","34","567"]
        print(strArr)//["121", "34", "567"]
        let strArr2 = strArr.filter { Int($0)==nil ? false : Int($0)! % 2 == 0}
        print(strArr2)//["34"]
    }
    
    
    //3、Array的常见操作 - reduce(归纳器)
    do{
        print("------3-------")
        let arr = [1,2,3,4]
        print(arr)//[1, 2, 3, 4]

        /**
         1、
         func reduce<Result>(_ initialResult: Result,
                             _ nextPartialResult: (Result, Int) throws -> Result) rethrows -> Result
         */
        let arr1 = arr.reduce(0) { (result:Int, item:Int) -> Int in
            result + item
        }
        print(arr1)//10
        
        
        //2、简写
        let arr2 = arr.reduce(0) { $0 + $1 }
        print(arr2)//10
        
        
        //3、简写
        let arr3 = arr.reduce(0, +)
        print(arr3)//10
        
        
        //4、函数
        func filterFun(result:Int,item:Int) -> Int{
           result + item
        }
        let arr4 = arr.reduce(0, filterFun(result:item:))
        print(arr4)//10
    }
   
    
    //4、map 与 flatmap的区别
    do{
        print("-------4------")
        let arr = [1, 2, 3]
        
        
        let arr2 = arr.map { Array.init(repeating: $0, count: $0) }
        print(arr2)// [[1], [2, 2], [3, 3, 3]]
        
        
        let arr3 = arr.flatMap { Array.init(repeating: $0, count: $0) }
        print(arr3)// [1, 2, 2, 3, 3, 3]
    }
    
    
    //5、map 与 compactMap
    do{
        print("-------5------")
        let arr = ["123", "test", "jack", "-30"]
        
        let arr2 = arr.map { Int($0) }
        print(arr2)// [Optional(123), nil, nil, Optional(-30)]
        
        let arr3 = arr.compactMap { Int($0) }
        print(arr3)// [123, -30]
    }
    
    
    //6、reduce实现map、filter的功能
    do{
        print("-------6------")
        // 使用reduce实现map、filter的功能
        let arr = [1, 2, 3, 4]
        
        //reduce实现map
        print(arr.map { $0 * 2 })               // [2, 4, 6, 8]
        print(arr.reduce([]) { $0 + [$1 * 2] }) // [2, 4, 6, 8]
        
        //reduce实现filter
        print(arr.filter { $0 % 2 == 0 })                       // [2, 4]
        print(arr.reduce([]) { $1 % 2 == 0 ? $0 + [$1] : $0 })  // [2, 4]
    }
    
}

//二、lazy的优化
func lazyUse() -> Void {
   
    //1、不用lazy的情况
    do{
        print("------1------")
        let arr = [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
         begin-----
         mapped 2
         mapped 4
         mapped 6
         end----
         */
    }
    
    
    
    //2、使用lazy的情况
    do{
        print("------2------")
        let arr = [1, 2, 3]
        
        //使用lazy后，不会在此时处理数据，使用时才会根据情况处理某条数据
        let result = arr.lazy.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----")
        
        /**
         begin-----
         mapping 1
         mapped 2
         mapping 2
         mapped 4
         mapping 3
         mapped 6
         end----
         */
    }
}

//三、Optional的map和flatMap
func optionalMapUse(){
    
    //1、Optional.map
    do{
        print("--------1------")
        let num1: Int? = 10
        
        //Optional 不为空解包后乘以2，将结果封包后返回
        let num2 = num1.map { $0 * 2 }
        print(num2 as Any)// Optional(20)
        
        let num3 = Optional<Int>.some(10).map{ (num:Int) -> Int in
            print("num = ",num)//num =  10
            return num * 2 //会对返回值进行包装
        }
        print(num3 as Any)//Optional(20)

        
        //Optional 为空直接返回nil
        let num4: Int? = nil
        let num5 = num4.map { $0 * 2 }
        print(num5 as Any)// nil
        
        let num6 = Optional.none.map { (num:Int) -> Int in
            print("num = ",num)//并未调用
            return num * 2
        }
        print(num6 as Any)// nil
    }
    
    

    //2、
    do{
        print("--------2------")
        let num1: Int? = 10
        print(num1 as Any)
        
        //会对闭包返回的结果进行包装
        let num2 = num1.map { Optional.some($0 * 2) }
        print(num2 as Any)// Optional(Optional(20))
        
        
        //会对闭包返回的结果智能包装 如果是可选类型就不再包装，直接返回
        let num3 = num1.flatMap { Optional.some($0 * 2) }
        print(num3 as Any)// Optional(20)
        
        let num4 = num1.flatMap { Optional.some(Optional.some($0 * 2)) }
        print(num4 as Any)
        
        //如果不是可选类型，包装后再返回
        let num5 = num1.flatMap { $0*2 }
        print(num5 as Any)//Optional(20)
    }
    
    
    //3、
    do{
        print("-----3-----")
        let num1: Int? = 10
        
        // num2、num3是等价的
        
        let num2 = (num1 != nil) ? (num1! + 10) : nil
        print(num2 as Any)//Optional(20)
        
        
        let num3 = num1.map { $0 + 10 }
        print(num3 as Any)//Optional(20)
        
        //以后三目运算符就可以使用map的方式
        let str:String? = "hehe"
        let str2 = str.map{$0 + "haha"}
        print(str2 as Any)//Optional("hehehaha")
    }
    
    
    //4、
    do{
        print("-----4-----")
        
        let fmt = DateFormatter()
        fmt.dateFormat   = "yyyy-MM-dd"
        let str: String? = "2011-09-10"
        
        // old
        let date1 = str != nil ? fmt.date(from: str!) : nil
        print(date1 as Any)//Optional(2011-09-09 16:00:00 +0000)
        
        // new1
        let date2 = str.map {
            fmt.date(from: $0)
        }
        print(date2 as Any)//Optional(Optional(2011-09-09 16:00:00 +0000))
        
        // new2
        let date3 = str.flatMap(fmt.date)
        print(date3 as Any)//Optional(2011-09-09 16:00:00 +0000)
        
        
        
        let score: Int? = 98
        
        // old
        let str1 = score != nil ? "socre is \(score!)" : "No score"
        print(str1)//socre is 98
        
        
        // new
        let str2 = score.map { "score is \($0)" } ?? "No score"
        print(str2)//socre is 98
    }
}

//四、Optional的map和flatMap
func optionalMapUse2(){

    struct Person {
        var name: String
        var age: Int
    }

    let items = [
        Person(name: "jack", age: 20),
        Person(name: "rose", age: 21),
        Person(name: "kate", age: 22)
    ]

    
    // old
    func getPerson1(_ name: String) -> Person? {
        //可选类型let index: Array<Person>.Index?
        let index = items.firstIndex { $0.name == name }
        return index != nil ? items[index!] : nil
    }
    print(getPerson1("jack") as Any)
    //Optional(LCClientDemo_commond.(unknown context at $10009d000).(unknown context at $10009d048).Person(name: "jack", age: 20))
    
    
    // new
    func getPerson2(_ name: String) -> Person? {
        return items.firstIndex { $0.name == name }.map { items[$0] }
    }
    print(getPerson2("rose") as Any)
    //Optional(LCClientDemo_commond.(unknown context at $10009d000).(unknown context at $10009d048).Person(name: "rose", age: 21))
}

//五、Optional的map和flatMap
func optionalMapUse3(){
    
    struct Person {
        
        var name: String
        var age: Int
        
        init?(_ json: [String : Any]) {
            guard let name = json["name"] as? String,
                  let age  = json["age" ] as? Int
            else {
                return nil
            }
            
            self.name = name
            self.age  = age
        }
    }
    
    
    let json: Dictionary? = ["name" : "Jack", "age" : 10]
    
    // old
    let p1 = json != nil ? Person(json!) : nil
    print(p1 as Any)
    
    // new1
    let p2 = json.flatMap { (dic:Dictionary<String, Any>) -> Person? in
        Person.init(dic)
    }
    print(p2 as Any)
    
    // new2
    let p3 = json.flatMap(Person.init)
    print(p3 as Any)
}