Swift3.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 + p2print("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 = -postlet alp = -nagprint("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 += p6print("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 = +++beDouprint("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)")}