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 + 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)")
}