Swift3.0－闭包、运算符重载

ゞ浴缸里的玫瑰 2023-10-17 10:13 25阅读 0赞

闭包（Closure）

自包含的函数代码块，可以在代码中被传递和调用

闭包可以捕获和存储其所在上下文中任意常量和变量的引用

闭包表达式：

(parameters) -> returnType in

statements

闭包可以使用常量、变量、inout类型作为参数，不提供默认值；元祖也可以作为参数和返回值

全局和嵌套函数实际上也是特殊的闭包

（1）全局函数是一个有名字但不会捕获任何值的闭包

（2）嵌套函数是一个有名字可以捕获其封闭函数域内值的闭包

（3）闭包表达式是一个捕获上下文变量和常量的匿名闭包

//！！！闭包的函数体部分由关键字in引入，该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始

/*
     * 闭包（Closure）
      自包含的函数代码块，可以在代码中被传递和调用
      闭包可以捕获和存储其所在上下文中任意常量和变量的引用
      闭包表达式：
        {  
            (parameters) -> returnType in
                statements
        }
      闭包可以使用常量、变量、inout类型作为参数，不提供默认值；元祖也可以作为参数和返回值
      全局和嵌套函数实际上也是特殊的闭包
     （1）全局函数是一个  有名字但不会捕获任何值 的闭包
     （2）嵌套函数是一个  有名字可以捕获其封闭函数域内值的闭包
     （3）闭包表达式是一个  捕获上下文变量和常量的匿名闭包
     */
    //！！！闭包的函数体部分由关键字in引入，该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始
    //sorted函数
    let names:Array<String> = ["China","Alex","Ewa","Draw","Bob"]
    let i = names.sorted {
        (s1, s2) -> Bool in
        return s1 > s2
    }
    print(i)
    
    //尾部闭包
    func someFunction(closure:() -> ()){
        //函数体部分
    }
    //以下是不使用尾随闭包进行函数调用
    someFunction (closure: {
        //闭包主体部分
    })
    //使用尾随闭包进行函数调用
    someFunction() {
        //闭包主体部分
    }
    
    let digitNames = [
        0:"Zero",1:"One",2:"Two",3:"Three",4:"Four",
        5:"Five",6:"Six",7:"Seven",8:"Eight",9:"Nine"
    ]
    let numbers = [16,58,510]
    func printOut() -> Void {
        let strings = numbers.map {
            (number) -> String in
            var number = number
            var output = ""
            while number > 0{
                output = digitNames[number % 10]! + output
                number /= 10
            }
            return output
        }
        print(strings)
    }
    printOut()
    
    
    /*
     * 运算符重载
      让已有的运算符可以对自定义的类和结构进行运算
     */
    struct Point {
        var x = 0.0,y = 0.0
    }
    func + (left:Point,right:Point) -> Point{
        return Point(x:left.x+right.x,y:left.y+right.y)
    }
    let p1 = Point(x:3.0,y:1.0)
    let p2 = Point(x:2.0,y:4.0)
    let p3 = p1 + p2
    print("p1=\(p1),p2=\(p2),p3=\(p3)")
    
    //前置、后置运算符(prefix、postfix)
    prefix func - (vector:Point) -> Point{
        return Point(x:-vector.x,y:-vector.y)
    }
    let post = Point(x:3.0,y:4.0)
    let nag = -post
    let alp = -nag
    print("post=\(post),nag=\(nag),alp=\(alp)")
    
    //组合赋值运算符
    func += (left:inout Point,right:Point){
        left = left + right
    }
    var p5 = Point(x:1.0,y:2.0)
    let p6 = Point(x:3.0,y:4.0)
    p5 += p6
    print("p5=\(p5)")
    
    //自定义运算符
    prefix operator +++
    prefix func +++ (vector:inout Point) -> Point{
        vector += vector
        return vector
    }
    var beDou = Point(x:1.0,y:4.0)
    let afterDou = +++beDou
    print("beDou=\(beDou),afterDou=\(afterDou)")
    
    /*
     * 泛型函数:作用于任何类型
      泛型使用了占位类型名字（通常用字母T来表示）来代替实际类型名字（如：Int、String等），占位类型名没有提示T必须是什么类型，但是它提示两个参数必须是同一类型T，不管T是什么类型，每次调用所传入实际类型才能决定T所代表类型
     */
    print("\n泛型函数")
    func swapTwoValues<T>(a:inout T,b:inout T){//要求两参数类型值一致
        let c = a
        a = b
        b = c
    }
    var beA = "测试"
    var beB = "test"
    swapTwoValues(a: &beA,b:&beB)
    print("a=\(beA),b=\(beB)")
    
    //栈操作
    print("\n栈操作")
    struct Stack<T>{
        var items = [T]()
        mutating func push(item:T){
            items.append(item)
        }
        mutating func pop() -> T{
            return items.removeLast()
        }
    }
    var stackString = Stack<String>()
    stackString.push(item: "ni")
    stackString.push(item: "wo")
    stackString.push(item: "ta")
    print(stackString.items)
    
    extension Stack{
        var topItem:T? {
            return items.isEmpty ? nil : items[items.count - 1]
        }
    }
    if let topItem = stackString.topItem{
        print("The top item on the stack is \(topItem)")
    }