可选项的本质
可选项的本质是
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)
