可选项的本质

可选项的本质是enum类型

public enum Optional<Wrapped> : ExpressibleByNilLiteral {
   case none
   case some(Wrapped)
   public init(_ some:Wrapped)
}

var age : Int? = 10
var age0: Optional<Int> = Optional<Int>.some(10)
var age1: Optional = .some(10)
var age2 = Optional.some(10)
var age3 = Optional(10)
age = nil
age = .none

var age: Int? = nil
var age0 = Optional<Int>.none
var age1: Optional<Int> = .none

var age: Int? = .none
age = 10
age = .some(20)
age = nil

溢出运算符

Swift 的算数运算符出现溢出时会抛出运行时错误
Swift 有溢出运算符（&+、&-、&*）,用来支持溢出运算

var v1 = UInt8.max
/// 编译器提示溢出错误
var v2 = v1 + 1
print(v2)

var v1 = UInt8.max
var v2 = v1 &+ 1
/// 打印结果：0
print(v2)

运算符重载

struct Point {
    var x = 0, y = 0
    static func + (p1:Point,p2:Point) -> Point {
        Point(x: p1.x + p2.x, y: p1.y + p2.y)
    }
}

var p1 = Point(x: 10, y: 20)
var p2 = Point(x: 11, y: 22)
let p3 = p1 + p2

Equatable

要想得知2个实例是否等价，一般做法是遵守Equatable协议，重载 ==运算符
与此同时，等价于重载了 !=运算符

class Person : Equatable {
    var age: Int
    init(age: Int) {
        self.age = age
    }
    static func == (lhs:Person,rhs:Person) -> Bool {
        lhs.age == rhs.age
    } 
}


var p1 = Person(age: 10)
var p2 = Person(age: 10)
print(p1 == p2)
print(p1 != p2)

Swift为以下类型提供默认的Equatable实现

• 没有关联类型的枚举
• 只拥有遵守Equatable协议的关联类型的枚举
• 只拥有遵守Equatable协议存储属性的结构体

引用类型比较存储的地址值是否相等（是否引用着同一个对象），使用恒等于运算符 ===，!==

Comparable

要想比较2个实例的大小，一般的做法是：
遵守Comparable协议
重载相应的运算符

/// score大的比较大，若score相等，age小的比较大
struct Student : Comparable {
    var age : Int
    var score : Int
    init(score:Int,age:Int) {
        self.score = score
        self.age = age
    }
    static func < (lhs: Student , rhs: Student) -> Bool {
        (lhs.score < rhs.score) || (lhs.score == rhs.score && lhs.age > rhs.age)
    }
    static func > (lhs: Student , rhs: Student) -> Bool {
        (lhs.score > rhs.score) || (lhs.score == rhs.score && lhs.age < rhs.age)
    }
    static func <= (lhs: Student , rhs: Student) -> Bool {
        !(lhs > rhs)
    }
    static func >= (lhs: Student , rhs: Student) -> Bool {
        !(lhs < rhs)
    }
}

扩展

Swift中的扩展，有点类似于OC中的分类

扩展可以为枚举、结构体、类、协议添加新功能
可以添加方法、计算属性、下标、便捷初始化器、嵌套类型、协议等等

扩展不能办的事情
不能覆盖原有的功能
不能添加存储属性，不能向已有的属性添加属性观察器
不能添加父类
不能添加指定初始化器，不能添加反初始化器

extension Double {
    var km: Double { self * 1000 }
    var m: Double { self }
    var dm: Double { self / 10 }
    var cm: Double { self / 100 }
    var mm: Double { self / 1000 }
}

var d = 100.0
print(d.km)
print(d.m)
print(d.km)