Swift－闭包

桃扇骨 2023-10-17 09:32 53阅读 0赞

闭包表达式

(参数) ->返回值类型 in

执行语句

/*
     1、 闭包表达式
     {
        (参数) -> 返回值类型 in
        执行语句
     }
     */
    print("1、 闭包表达式")
    let sayHello = {
        print("hello")
    }
    sayHello()
    
    let add:(Int,Int) -> Int = {
        (a:Int,b:Int) -> Int in
        return a+b
    }
    print(add(3,2))
    
    /*
     2、 闭包表达式作为函数回调
     {
     (参数) -> 返回值类型 in
     执行语句
     }
     */
    print("\n2、 闭包表达式作为函数回调")
    func showArray(array:[Int]){
    //    for i in array{
    //        print("\(i) ")
    //    }
        print(array)
    }
    
    //冒泡排序
    //func bubbleSort(array:inout [Int]){
    //    for i in 1 ..< array.count
    //    {
    //        for j in 0 ..< array.count - i
    //        {
    //            if array[j] > array[j+1]
    //            {
    //                let t = array[j]
    //                array[j] = array[j + 1]
    //                array[j+1] = t
    //            }
    //        }
    //    }
    //}
    func bubbleSort(array:inout [Int],cmp:(Int,Int) -> Int){
        for i in 1 ..< array.count
        {
            for j in 0 ..< array.count - i
            {
                if cmp(array[j],array[j+1]) == -1
                {
                    let t = array[j]
                    array[j] = array[j + 1]
                    array[j+1] = t
                }
            }
        }
    }
    
    
    var arr = [20,30,4,5,80]
    showArray(array:arr)
    let intCmp:(Int,Int) -> Int = {
        (a:Int,b:Int) -> Int in
        if a>b{
            return -1
        }else if a<b {
            return 1
        }
        else{
            return 0
        }
    }
    //bubbleSort(array: &arr)
    //bubbleSort(array: &arr,cmp:intCmp)
    
    //闭包表达式优化（类型推断机制--根据已经定义好的参数、返回值类型进行省略，且可以使用$符号进行参数省略，即 $0: 表示第一个参数）
    bubbleSort(array:&arr,cmp:{
        if $0>$1 {
            return -1
        }else if $0<$1 {
            return 1
        }
        else{
            return 0
        }
    })
    showArray(array: arr)
    
    //.sort-系统冒泡排序
    arr.sort{
        (a:Int,b:Int) -> Bool in
        return a>b
    }
    showArray(array: arr)
    
    /*
     3、嵌套函数
     */
    print("\n3、嵌套函数")
    func swap(a:inout Int,b:inout Int){
        let t = a
        a = b
        b = t
    }
    
    //冒泡排序
    func bubbleSortFunc(array:inout [Int]){
        for i in 1 ..< array.count
        {
            for j in 0 ..< array.count - i
            {
                if array[j] > array[j+1]
                {
                    swap(a:&array[j], b:&array[j+1])
                }
            }
        }
    }
    bubbleSortFunc(array: &arr)
    showArray(array: arr)
    
    /*
     4、闭包捕获值
     */
    print("\n4、闭包捕获值")
    //嵌套函数
    func getFuncValue(inc:Int) -> (Int) -> Int{
        //内部函数（局部的），捕获了上下文的值
        var m = 10 //对值进行保存并增加
        func inFunc(v:Int) -> Int{
            //var m = 10 //写在里面值不会被保存增加
            m += 1
            return inc+v+m
        }
        return inFunc
    }
    let getFunc1 = getFuncValue(inc: 2)
    let getFunc2 = getFuncValue(inc: 2)//每个函数都有自己独有的一份闭包
    print(getFunc1(10))
    //这时将m = 11当成了一个全局变量进行保存，因此值在不断增加
    print(getFunc1(10))
    print(getFunc2(10))