1。枚举可以知道类型值及初始值，甚至可以使用touple（需要touple实现hashable）case 里可以使用条件判断
enum aN:Int{
case a = 0
case b = 3
func getRaw -> String {
switch self {
case a:
return "aaa"
//可以在case里使用条件
case let z where z > 2:
return "bbbb"
}
}
}
2.基本数据类型定义可使用下划线分开
let one = 1_000_000
let two = 1_.000_000
3.二进制，八进制，十六进制
let two = 0b10001
let eight = 0o21
let sixtheen = 0x11
let stander = 1.23423e1 科学计数法
let sSix = 0xC.3p0 16进制科学计数法
4. 替换数组里的元素.可用作删除元素
var arr = [1,2,3,4,5]
arr[1...4] = [7,8] => [1,7,8]
5. 三目运算符
let a = b != nil ? b!:2
let a = b ?? 2 //如果b不为nil则b赋值给a，若b为nil则将2赋值给b后在赋给a，所以当b是多级可选时候(let b :Int ??? = nil) 这时候打印a则是option（Option(2)）,因为解第一层的时候b是nil，将2赋给b （b == Int:?? = 2）
6. switch case 中需要继续进行下面的case，使用fallthrough，对比break的跳出
7. guard 可以跳过if的第一个执行体，直接写else
正常 if let a = b {} else {}
特殊: guard let a = b else {}
8.case的妙用
for thing in things {
switch thing {
case 0 as Int: // 如果值等于0 请检测是不是Int
print("zero as an Int")
case 0 as Double:// 和上面类型
print("zero as a Double")
case let someInt as Int: // 模式匹配上面的值,检测是不是Int
print("an integer value of \(someInt)")
case let someDouble as Double where someDouble > 0:// 模式匹配上面的值 检测是不是double 并且判断它是不是大于0
print("a positive double value of \(someDouble)")
case is Double: // 检测是不是double类型
print("some other double value that I don't want to print")
case let someString as String: // 模式匹配是不是String类型
print("a string value of \"\(someString)\"")
case let (x, y) as (Double, Double): // 模式匹配是不是元组类型,并且检测数据类型
print("an (x, y) point at \(x), \(y)")
case let movie as Movie:
print("a movie called \(movie.name), dir. \(movie.director)")
case let stringConverter as (String) -> String:
print(stringConverter("Michael"))
default:
print("something else")
}
}
9. lazy关键字只能用户存储属性，且必须初始化，结构体中使用lazy的属性在访问的方法前必须加mutating，lazy不能用于全局变量或静态常量， lazy修饰的存储属性只能初始化一次，在多线程访问的时候，不需要使用lazy标识
struct Cat {
lazy var name = "动物"
//struct中方法访问lazy修饰的属性，需要加mutatihg
mutating func catName () ->String {
return name
}
}
10. static 和Class
相同：1.可以修饰方法，static修饰的方法叫静态方法，class修饰的叫类方法
2. 都可以修饰计算属性
不同: 1.class不能修饰存储属性
2. class 修饰的计算属性可以被重写，static修饰的不能被重写
3. static可以修饰存储属性，称为静态变量(常量)
4. static 修饰的静态方法不能被重写，class修饰的类方法可以重写
5.class修饰的类方法重写时，可以使用static让方法变成静态方法，这时候它的子类就不能再重写了
6.class只能在类中使用，static可以在类，结构体，枚举中使用
class/Static override func des (){ }
11. swift中struct，Arryay，Dictionary都不是引用类型，区别于OC中数组于字典的引用类型
12.需要改变方法函数里参数的值，需要使用inout修饰(想起了c++),取到了属性的内存指针
func swap(a: inout Int, b: inout Int) -> Int{
a = a+b
b = a - b
a = a - b
或者
(a,b) = (b,a) 好厉害的元组啊
}
swap(a: &3, b: &7)
注意: 1.inout修饰的参数不能有默认值，不能用于修饰多值（a:Int...）
定义函数类型的变量
var swap1 = (intout Int, inout Int) -> Int = swap
var swap2 = （_:Inout Int, _: inout Int） -> Int = swap
var swap3 = （_ a :Inout Int, _ sencond: inout Int） -> Int = swap
13. 方法函数定义了带有返回值，系统默认给方法的属性是@warn_unused_result ，有返回值不用会发生警告，使用@discardableResult 消除警告
@discardableResult
func getString() -> String {returm “啊啊”}
14. @autoclouse 自动闭包
第一种 不加自动闭包
func server(load: () -> String ) {
print(load)
}
server {load: () -> String in
return "没加autoclosure"
}
第二种添加自动闭包
func server(load : @autoclosure () -> String) {
print(load)
}
server(load: "加了autoclosure")
系统自动帮你闭包了，下面一步步添加省略掉的
server(load: {"加了autoclosure"})
server(load: { return "加了autoclosure"})
server(load: { () in return "加了autoclosure" })
15. @escaping 逃逸闭包，可以被引用的closure， @noescape不能被引用，不能被异步执行
16. 类初始化需要使用指定初始化方法，可以有多个指定初始化方法，也可以多个convienience初始化方法，每个便利初始化方法必须有一个指定初始化方法，也可以使用其它含有指定初始化的便利初始化方法，子类的便利初始化必须使用自己的指定初始化方法，父类的required修饰的初始化方法(指定，或便利)子类必须重载实现。 deinit反初始化，相当于oc dealoc。
swift初始化顺序是，先构造方法初始化，属性初始化，分配内存，然后调用父类指定初始化，依次类推。
oc 先调用alloc来分配存储空间，返回分配名单对象，在init对对象进行初始化，先调用父类初始化在调用子类，区别于swift
