元组
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
