十五、可选项的本质、高级运算符(重载)、扩展

可选项的本质

可选项的本质是enum类型

Wrapped为泛型

var age: Int? = 10
age = 20
age = nil

//结合枚举及泛型理解
var age1: Optional = .some(10)
age1 = .some(20)
age = .none

var age: Int? = 10

var age2: Optional = Optional.some(10)//完整写法
var age3: Optional = .some(10)//通过10将Optional泛型类型确定
var age4 = Optional.some(10)//枚举变量赋值
var age5 = Optional(10)//枚举初始化器

age = nil//语法糖
age2 = .none//显式
var age6 = Optional.none//确定泛型类型 所以Int必须写
var age7 :Optional = .none

print(age == age2)//输出：true 就是一样的 仅写法不同

因此也可以通过Switch和if语句进行判断

switch age {
case let age? :
    print(age)
case nil :
    print("nil")
}

switch age {
case let .some(v) :// .some(let v) 都可以
    print(v)
case nil :
    print("nil")
}

多重可选类型

var age: Int? = 10
var age1: Int?? = age
age1 = nil

var age2 = Optional.some(Optional.some(10))
age2 = .none
var age3: Optional> = .some(.some(10))
var age4: Optional = .some(.some(10))

var age5: Int?? = 10
var age6: Optional = 10

高级运算符

溢出运算符

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

var min = UInt8.min //0
//min -= 1//此时会运行时错误
min = min &- 1 //255 UInt8.max

var max = UInt8.max //255
//max += 1//此时会运行时错误
max = max &+ 1 //0 UInt8.min

max = UInt8.max
print(max &* 2)//max+1+254 = 254

溢出运算符图解

运算符重载

• 类、结构体、枚举可以为现有的运算符提供自定义的实现，即运算符重载

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: 10) + Point(x: 20, y: 20)
print(p)//Point(x: 30, y: 30)

struct Size {
    var width: Int ,height: Int
    //如果需要写在结构体中 需要加上static
    static func + (_ s1: Size, _ s2: Size) -> Size {
        Size(width: s1.width + s2.width, height: s1.height + s2.height)
    }
}

let s = Size(width: 10, height: 10) + Size(width: 20, height: 20)
print(s)//Size(width: 30, height: 30)

struct Size {
    var width: Int ,height: Int
    //如果需要写在类、结构体中 需要加上static 因为这不是实例调用的函数
    static func + (_ s1: Size, _ s2: Size) -> Size {
        Size(width: s1.width + s2.width, height: s1.height + s2.height)
    }
    
    static func - (_ s1: Size, _ s2: Size) -> Size {
        Size(width: s1.width - s2.width, height: s1.height - s2.height)
    }
    
    static func += (_ s1: inout Size, _ s2: Size){
        s1 = s1 + s2
    }
    
    static prefix func ++ (_ s1: inout Size) -> Size {//前++运算符
        s1 += Size(width: 1, height: 1)
        return s1
    }
    
    static postfix func ++ (_ s1: inout Size) -> Size {//后++运算符
        let tmp = s1
        s1 += Size(width: 1, height: 1)
        return tmp
    }
    
    static func == (_ s1: Size, _ s2: Size) -> Bool { //判断相等
        return (s1.width == s2.width)&&(s1.height == s2.height)
    }
}

Equatable

1. Equatable协议

• 想确定2个实例是否等价，一般是遵守Equatable协议，重载==运算符
• 与此同时，等价于重载了** != **运算符

2. Swift提供默认的Equatable实现

• 没有关联类型的枚举
• 只遵守Equatable协议关联类型的枚举
• 只遵守Equatable协议存储属性的结构体（即如果结构体中的某些实例属性未遵守，则不行）

3. 引用类型比较存储的地址值是否相等（是否引用同一个对象） 使用(=== 、!==)

class Person : Equatable {//不遵守 重载==运算符也可以 
//作用：
//1、声明Person可以使用==判断 可以调用下面的equals函数
//2、自动重载 != 运算符
    var age: Int
    init(age: Int) {
        self.age = age
    }
    static func == (p1 :Person,p2 :Person) -> Bool {
        p1.age == p2.age
    }
}

var p1 = Person(age: 10)
var p2 = Person(age: 10)
print(p1 == p2)//true

//只有遵守Equatable协议的泛型才可以使用该函数
func equals(_ t1: T,_ t2: T) -> Bool{
    t1 == t2
}

print(equals(p1, p2))//true

//无关联类型的的枚举
enum Season: Equatable {
    case spring,summer,autoum,winter
}
var season1 = Season.winter
var season2 = Season.spring

print(season1 == season2)//false
print(season1 != season2)//true 自动重载!=运算符

//只遵守Equatable协议关联类型的枚举
enum Score: Equatable {
    case score(Int)
    case grade(String)
}

var score1 = Score.score(80)
var score2 = Score.score(90)

print(score1 == score2)//false
print(score1 != score2)//true 自动重载!=运算符


//只拥有遵守Equatable协议的存储属性的结构体
class Person {
    var age: Int
    init(age: Int) {
        self.age = age
    }
}

struct Point : Equatable{
//    static func == (lhs: Point, rhs: Point) -> Bool {//因为Person未遵守 所以需要重载==运算符
//        lhs.x == rhs.x &&
//        lhs.y == rhs.y &&
//        lhs.a == rhs.a &&
//        lhs.p.age == rhs.p.age
//    }
    //遵守Equatable的结构体
    var x: Int ,y: Int
    var a :Array = [Int]()//可想而知Int、Array等常用数据类型是遵守Equatable协议的
    //var p :Person = Person(age: 10)//如果其存储属性未遵守Equatable协议 则必须重载==运算符
    
}

var p1 = Point(x: 10, y: 20)
var p2 = Point(x: 10, y: 20)
print(p1 == p2)//true
print(p1 != p2)//false 自动重载!=运算符

var p1 = Person(age: 10)
var p2 = p1
print(p1 === p2)//引用类型比较存储的地址是否相等（是否引用同一个对象）

Comparable

• 想要比较两个实例的大小：遵守Comparable协议，重载相应的运算符

//比较两个学生的能力 成绩优先 成绩相同，年龄小更优秀
struct Student : Comparable {
    
    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)
    }
    
    var age :Int
    var score :Int
}

var student1 = Student(age: 10, score: 69)
var student2 = Student(age: 12, score: 69)
var student3 = Student(age: 11, score: 89)
var student4 = Student(age: 13, score: 89)

print(student1 > student2) //true
print(student1 >= student3)//false
print(student3 < student4) //false
print(student3 <= student4)//false
print(student1 <= student4)//true

自定义运算符

在全局作用域中使用opretor进行声明

• prefix opretor 前缀运算符
• postfix opretor 后缀运算符
• infix opretor 中缀运算符 : 优先级组（需要定义结合性、优先级等等）

自定运算符实例 --前后自减运算符 +- 前加后减

prefix operator --
postfix operator --

infix operator +- : PlusMinusPrecedence
precedencegroup PlusMinusPrecedence{
    associativity: none
    higherThan: AdditionPrecedence
    lowerThan: MultiplicationPrecedence
    assignment: true
}

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 prefix func  -- (p1:inout Point) -> Point{
        p1 = p1 - Point(x: 1, y: 1)
        return p1
    }
    
    static postfix func  -- (p1:inout Point) -> Point{
        let tmp = p1
        p1 = p1 - Point(x: 1, y: 1)
        return tmp
    }
    
    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 ?? 0 + p2.x, y: p1?.y ?? 0 - p2.y)
    }
}

var point1 = Point(x: 10, y: 20)
var point2 = Point(x: 11, y: 22)
print(--point1)//point1 : Point(x: 9, y: 19) 先计算，再输出 Point(x: 9, y: 19)
print(point1--)//point1 : Point(x: 8, y: 18) 先输出Point(x: 9, y: 19)，再自减
print(--point1 - point1--)//结果为：Point(x: 0, y: 0) ！！！会出现歧义，所以Swift去除自增自减是明智的

扩展(Extension)

什么是扩展

1. Swift中的扩展，类似于OC中的分类(Category)
2. 扩展可以为枚举、结构体、类、协议添加新功能

• 可以添加方法、计算属性、下标、(便捷)初始化器、嵌套类型、协议等

3. 扩展不能办到的事情（不能影响内存结构以及破坏安全性）

• 不能覆盖原有功能（OC可以覆盖）
• 不能添加存储属性 （OC通过runtime添加）
• 不能添加父类
• 不能添加指定初始化器，不能添加反初始化器
  ...

添加方法、计算属性、下标、嵌套类型

//新增计算属性
extension Double{
    var km:Double { self * 1_000.0 }
    var m:Double { self }
    var dm:Double { self / 10.0 }
    var cm:Double { self / 100.0 }
    var mm:Double { self / 1_000.0 }
}

var d = 100.0
print(d.km)//100000.0
print(d.m) //100.0
print(d.dm)//10.0
print(d.cm)//1.0
print(d.mm)//0.1

//新增下标
extension Array{
    //避免数组下标越界
    subscript(nullable idx: Int) -> Element?{
        if (startIndex.. Void) {
        for _ in 0.. Int {
        self = self * self
        return self
    }
    
    //新增计算属性 判断正负号
    enum Kind {
        case negative,zero,positive
    }
    var kind :Kind {
        switch self {
        case 0:
            return .zero
        case let x where x > 0 :
            return .positive
        default:
            return .positive
        }
    }
    
    //获取第*位数字
    subscript(digitIndex: Int) -> Int{
        var decimalBase = 1
        for _ in 0 ..< digitIndex{
            decimalBase *= 10
        }
        return (self / decimalBase) % 10
    }
}

var num = 10
num.repeats {
    print("hello!")//重复打印10次
}

print(num.square())//输出：100

print(num.kind)//输出：positive

print(num[2])//十位为1 输出：1 

初始化器

• 如果希望自定义初始化器的同时，编译器也能够生成默认初始化器，可以在扩展中添加
• 类遵守协议实现的required初始化器，不能写在扩展中

class Person{
    var age :Int
    var name :String
    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
}

extension Person : Equatable{
    static func == (lhs: Person, rhs: Person) -> Bool {
        lhs.age == rhs.age && lhs.name == rhs.name
    }
    convenience init() {
        self.init(age:10,name:"盖伦")
    }
}

var p1 = Person()
print(p1.age,p1.name)//输出：10 盖伦


struct Point {
    var x: Int = 0
    var y: Int = 0
}

extension Point{
    init(_ point: Point) {
        self.init(x: point.x, y: point.y)
    }
}

//编译器生成默认初始化器，同时可以自定义初始化器
var po1 = Point()
var po2 = Point(x: 10)
var po3 = Point(y: 10)
var po4 = Point(x: 10,y: 10)
var po5 = Point(po4)

协议

1. 如果一个类已经实现了协议中的所有要求，但是还没有声明它遵守了这个协议，则可以通过扩展让他遵守这个协议
2. 扩展可以给协议提供默认实现，也间接实现「可选协议的效果」
3. 扩展可以给协议扩从「协议中从未声明过的方法」

//示例1
protocol TestProcotol {
    func test()
}

class Person {
    func test() {
        print("test")
    }
}

extension Person :TestProcotol{

}

//示例1
//BinaryInteger 是Int UInt8 UInt16等共同遵循的协议
//方法一：
func isOdd(_ i:T)-> Bool{
    i % 2 != 0
}
print(isOdd(5))//输出：true

//方法二：给协议扩展方法
extension BinaryInteger{
    func isOdd() -> Bool {
        self % 2 != 0
    }
}
print(5.isOdd())//输出：true

protocol TestProcotol {
    func func1()
}

class Person :TestProcotol {
    //如果扩展中没有实现，则必须实现协议中的方法 否则编译报错
    func func1() {
        print("PersonClass func1")
    }
    
    func func2() {
        print("PersonClass func2")
    }
}

//如果可以在协议扩展中实现或补充 继承该协议的类可以不用实现协议中的方法
extension TestProcotol{
    func func1() {
        print("extension func1")
    }
    func func2() {
        print("extension func2")
    }
}

var person :TestProcotol = Person()
//func1在扩展中已经实现
person.func1()//PersonClass func1
//func2在原协议中没有
person.func2()//extension func2

疑问：为什么func2()输出会不同呢？
如果person实例后面没有加TestProcotol 则输出为PersonClass func2 加了之后就是extension func2 因为原协议中没有声明func2，因此：
原协议中有的方法，优先实例对象中实现的方法
原协议中没有的方法，如果实例有声明该协议，则优先协议扩展中的方法；没有声明，优先自己

泛型

• 扩展中依然可以使用原类型中的泛型类型
• 泛型符合条件才扩展

class Stack {
    var elements = [Element]()
    init(_ numbers:Element...) {
        self.elements = numbers
    }
    func push(_ element:Element) {
        elements.append(element)
    }
    func pop() -> Element {
        elements.removeLast()
    }
    
}

//泛型中依然可以使用原类型中的扩展
extension Stack{
    func top() -> Element {
        elements.last!
    }

    func size() -> Int {
        elements.count
    }
}

//符合条件才扩展
extension Stack where Element : Equatable{
    static func == (left:Stack,right:Stack) -> Bool {
        left.elements == right.elements
    }
}

var s1 = Stack(10,20,30)
var s2 = Stack(10,20,30)
print(s1 == s2)//true

var s3 = Stack(Stack(10),Stack(20),Stack(30))//元素不符合
var s4 = Stack(10,20,30)
print(s3 == s4)//元素不符合 编译报错