swift-14-可选项的本质、运算符重载、扩展
一、可选项的本质
1.1 可选项的本质是enum类型
public enum Optional<Wrapped> : ExpressibleByNilLiteral
case none
case some(Wrapped)
public init_ some: Wrapped)
}1.2 平时写的可选项对应的原始写法
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
age3 = .nonevar age: Int? = nil
var age0 = Optional<Int>.none
var age1: Optional<Int> = .none可以混合写
var age: Int? = .none
age = 10
age = .some(20) age = nil1.3 平时我们写的非枚举可选(本质就是枚举)和非可选类型支持switch 的写法
var age: int ? = 10
switch age {case let v?:
print("some", v)
case nil:
print("none")
}
上面的写法等价于
if let v = age
｛
print("1", v)
｝
else {
print ("2" )
｝
var age: int = 10 switch age {
case let .some(v):
print("some", v)
case .none:
print("none")
}1.4 多重可选项
var age_: Int? = 10
var age: Int?? = age_
age = nilvar age0 = Optional.some(Optional.some(10)) age0 = .none
var age1: Optional<Optional> = .some(.some(10)) age1 = .nonevar age: Int?? = 10
var age0: Optional<Optional> = 10二、溢出运算符（Overflow Operator）
2.1 类型范围区间
print(Int8.min) // -128print(Int8.max) // 127print(UInt8.min) // 0
print(UInt8.max) // 2552.2 那么溢出之后如何处理
Swift的算数运算符出现溢出时会抛出运行时错误
Swift有溢出运算符（ &+、 &-、 &*），用来支持溢出运算
假如范围是-128到127 之间，只用溢出运算符（ &+、 &-、 &*）后，数字依然会在-128到127这间进行变化，例如 当前数是a=127 使用了b=a&+ 1 ，那么b的值是-127，又回到最小的-127了
var min = UInt8.min
print(min &- 1) // 255, Int8.maxvar max = UInt8.max
print(max &+ 1) // 0, Int8.min
print(max &* 2) // 254, 等价于 max &+ max三、运算符重载（ Operator Overload ）
类、结构体、枚举可以为现有的运算符提供自定义的实现，这个操作叫做：运算符重载
注：重载的运算符一般放在对应的类、结构体、枚举内，写成static 的形式
struct Point {
var x: Int, y: Int
}func + (p1: Point, p2: Point) -> Point {
Point(x: p1.x + p2.x, y: p1.y + p2.y)
}let p = Point(x: 10, y: 20) + Point(x: 11, y: 22)
print(p) // Point(x: 21, y: 42)struct Point {
var x: Int, y: Int
static func + (p1: Point, p2: Point) -> Point {
Point(x: p1.x + p2.x, y: p1.y + p2.y)
}static func + (p1: Point, p2: Point) -> Point {
Point(x: p1.x + p2.x, y: p1.y + p2.y)
}
static func - (p1: Point, p2: Point) -> Point {
Point(x: p1.x - p2.x, y: p1.y - p2.y)
}
static prefix func - (p: Point) -> Point {
Point(x: -p.x, y: -p.y)
}
static func += (p1: inout Point, p2: Point) {
p1 = p1 + p2 }}static prefix func ++ (p: inout Point) -> Point {
p += Point(x: 1, y: 1)
return p
}
static postfix func ++ (p: inout Point) -> Point {
let tmp = p
p += Point(x: 1, y: 1) return tmp
}
static func == (p1: Point, p2: Point) -> Bool {
(p1.x == p2.x) && (p1.y == p2.y)
}四、Equatable
要想得知2个实例是否等价，一般做法是遵守 Equatable 协议，重载 == 运算符
1、与此同时，等价于重载了 != 运算符
struct Point : Equatable { var x: Int, y: Int
}
var p1 = Point(x: 10, y: 20)
var p2 = Point(x: 11, y: 22)
print(p1 == p2) // false
print(p1 != p2) // true注：有两种方式实现，第一种是遵守Equatable，第二种重载==运算符，但是一般情况下如果要比较2个实例是否等价，都需要遵守Equatable，因为如果我要定义一个比较方法带范型的参数的时候，范型参数需要制定具体的遵守的类型
4.2 Swift为以下类型提供默认的 Equatable 实现
1、没有关联类型的枚举
enum Answer {
case wrong case right
｝
var s1 = Ayswer. wrong
var s2 = Answer.right
print (s1 == s2)
2、只拥有遵守 Equatable 协议关联类型的枚举（枚举遵守 Equatable不用实现Equatable定义的方法，但其他的必须实现Equatable定义的方法才行）
3、只拥有遵守 Equatable 协议存储属性的结构体
一下Point : Equatable 提供了默认的实现，Point遵守Equatable也不用再去实现Equatable定义的方法
struct Point : Equatable {
var x = 0, y = 0
}4、如果是类的话，必须自己实现Equatable定义的额方法
5、引用类型比较存储的地址值是否相等（是否引用着同一个对象），使用恒等运算符 === 、 !==
