元组

let a = (1, 2, 3)

print(a.1)        //打印第二位的值

var arr = [1, 2, 3, 4, 5, 6]
print(arr)        //打印数组里面的所有值

func b() -> (Int, Int, Int) {
    return(22, 33, 44)
}

var (e, f, g) = b()       //把e,f,g分别赋给b()里面的值
print(e, f, g)

defer 延时执行

func delayCall() {
    var i = 0
    
    defer {
        print("first defer", i)     //第四执行
        
    }
    
    i = 1
    
    defer {
        print("second defer", i)    //第三执行
    }
    
    i = 2
    print("first", i)           //第一执行
    print("second")             //第二执行
}
print(delayCall())

Any 任意类型

var arc = [Any]()         //根据后面调用的值，自动转换类型
arc.append(1)
arc.append(2.0)
arc.append("abc")
print(arc)
//as 不能改变数据的类型，只能明确类型（确认）
var a1: Double = arc[1] as! Double     //a1等于上面arc第二位的值
let b1 = a1 + 2                        //2.0 + 2 = 4.0
print(b1)                              //打印出 4.0

@autuclosure 自动封包

func executeClosure(@autoclosure c: () -> Bool) {
    if c() {
        print("1 > 2")
    }
    else {
        print("1 < 2")
    }
}

executeClosure(1 > 3)

//inout  函数里面改变函数外面的变量

var (y, z) = (1, 2)

func swapAB(inout a: Int, inout b:Int) {
    (y, z) = (z, y)
}
//inout类型的参数，只能传递变量，并且需要加符号 &
//可以在函数里面修改函数的参数，同事影响外面的变量
swapAB(&y, b:&z)

print(y, z)

lazy 懒加载

第一次使用时才加载初识化值

//新建一个文件 Animal

class Animal {
    //1. 必须要第一次使用时才执行
    //2. 只会执行一次
    lazy var name: String = {
        print("正在初始化")
        return "abc"
    }()       //记得还有个小括号
}

let Ani01 = Animal()    //赋值
print(Ani01.name)      //调用，打印Ani01的名字，显示"正在初始化"，"abc"
print(Ani01.name)      //第二次打印（使用时）不再显示"正在初始化"

泛型 <>

//函数泛型/模板函数 占位符

func printV<V>(a: V) {
    print(a)
}

printV(1.3)       //printV(a: Double)
printV("aaa")     //printV(a: String)

泛型类，模板类 class <>

先进后出，先存的数据后取出来

class Stack<T> {
    var container = [T]()
    
    func push(a: T) {
        container.append(a)
    }
    
    func pop() -> T {
        return container.removeLast()
    }
}

//let arr = Array<Int>()

let s = Stack<Int>()
s.push(234)           //存入值 234
s.push(35)            //存入值35

print(s.pop())       //先存的后取，所以这里打印的是35
print(s.pop())       //这里打印的是234

let ss = Stack<String>()
//ss.container