可選項的本質(zhì)

可選項的本質(zhì)是enum類型

Wrapped為泛型

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

//結(jié)合枚舉及泛型理解
var age1: Optional<Int> = .some(10)
age1 = .some(20)
age = .none

var age: Int? = 10

var age2: Optional<Int> = Optional<Int>.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<Int>.none//確定泛型類型 所以Int必須寫
var age7 :Optional<Int> = .none

print(age == age2)//輸出：true 就是一樣的 僅寫法不同

因此也可以通過Switch和if語句進(jìn)行判斷

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<Optional<Int>> = .some(.some(10))
var age4: Optional<Optional> = .some(.some(10))

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

高級運算符

溢出運算符

• Swift的算術(shù)運算符出現(xiàn)溢出時會拋出運行時錯誤
• 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

溢出運算符圖解

運算符重載

• 類、結(jié)構(gòu)體、枚舉可以為現(xiàn)有的運算符提供自定義的實現(xiàn)，即運算符重載

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
    //如果需要寫在結(jié)構(gòu)體中 需要加上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
    //如果需要寫在類、結(jié)構(gòu)體中 需要加上static 因為這不是實例調(diào)用的函數(shù)
    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協(xié)議

• 想確定2個實例是否等價，一般是遵守Equatable協(xié)議，重載==運算符
• 與此同時，等價于重載了** != **運算符

2. Swift提供默認(rèn)的Equatable實現(xiàn)

• 沒有關(guān)聯(lián)類型的枚舉
• 只遵守Equatable協(xié)議關(guān)聯(lián)類型的枚舉
• 只遵守Equatable協(xié)議存儲屬性的結(jié)構(gòu)體（即如果結(jié)構(gòu)體中的某些實例屬性未遵守，則不行）

3. 引用類型比較存儲的地址值是否相等（是否引用同一個對象） 使用(=== 、!==)

class Person : Equatable {//不遵守 重載==運算符也可以 
//作用：
//1、聲明Person可以使用==判斷 可以調(diào)用下面的equals函數(shù)
//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協(xié)議的泛型才可以使用該函數(shù)
func equals<T :Equatable>(_ t1: T,_ t2: T) -> Bool{
    t1 == t2
}

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

//無關(guān)聯(lián)類型的的枚舉
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協(xié)議關(guān)聯(lián)類型的枚舉
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協(xié)議的存儲屬性的結(jié)構(gòu)體
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的結(jié)構(gòu)體
    var x: Int ,y: Int
    var a :Array = [Int]()//可想而知Int、Array等常用數(shù)據(jù)類型是遵守Equatable協(xié)議的
    //var p :Person = Person(age: 10)//如果其存儲屬性未遵守Equatable協(xié)議 則必須重載==運算符
    
}

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

• 想要比較兩個實例的大?。?strong>遵守Comparable協(xié)議，重載相應(yīng)的運算符

//比較兩個學(xué)生的能力 成績優(yōu)先 成績相同，年齡小更優(yōu)秀
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進(jìn)行聲明

• prefix opretor 前綴運算符
• postfix opretor 后綴運算符
• infix opretor 中綴運算符 : 優(yōu)先級組（需要定義結(jié)合性、優(yōu)先級等等）

自定運算符實例 --前后自減運算符 +- 前加后減

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--)//結(jié)果為：Point(x: 0, y: 0) ?。。霈F(xiàn)歧義，所以Swift去除自增自減是明智的

擴展(Extension)

什么是擴展

1. Swift中的擴展，類似于OC中的分類(Category)
2. 擴展可以為枚舉、結(jié)構(gòu)體、類、協(xié)議添加新功能

• 可以添加方法、計算屬性、下標(biāo)、(便捷)初始化器、嵌套類型、協(xié)議等

3. 擴展不能辦到的事情（不能影響內(nèi)存結(jié)構(gòu)以及破壞安全性）

• 不能覆蓋原有功能（OC可以覆蓋）
• 不能添加存儲屬性 （OC通過runtime添加）
• 不能添加父類
• 不能添加指定初始化器，不能添加反初始化器
  ...

添加方法、計算屬性、下標(biāo)、嵌套類型

//新增計算屬性
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

//新增下標(biāo)
extension Array{
    //避免數(shù)組下標(biāo)越界
    subscript(nullable idx: Int) -> Element?{
        if (startIndex..<endIndex).contains(idx){
            return self[idx]
        }
        return nil
    }
}

var arr = [10,20,30]
print(arr[nullable: 5])//輸出：nil

//新增方法
extension Int {
    //重復(fù)某個方法
    func repeats(task:() -> Void) {
        for _ in 0..<self {
            task()
        }
    }
    
    //新增方法 返回該數(shù)的平方數(shù)
    mutating func square() -> Int {
        self = self * self
        return self
    }
    
    //新增計算屬性 判斷正負(fù)號
    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
        }
    }
    
    //獲取第*位數(shù)字
    subscript(digitIndex: Int) -> Int{
        var decimalBase = 1
        for _ in 0 ..< digitIndex{
            decimalBase *= 10
        }
        return (self / decimalBase) % 10
    }
}

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

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

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

print(num[2])//十位為1 輸出：1 

初始化器

• 如果希望自定義初始化器的同時，編譯器也能夠生成默認(rèn)初始化器，可以在擴展中添加
• 類遵守協(xié)議實現(xiàn)的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)
    }
}

//編譯器生成默認(rèn)初始化器，同時可以自定義初始化器
var po1 = Point()
var po2 = Point(x: 10)
var po3 = Point(y: 10)
var po4 = Point(x: 10,y: 10)
var po5 = Point(po4)

協(xié)議

1. 如果一個類已經(jīng)實現(xiàn)了協(xié)議中的所有要求，但是還沒有聲明它遵守了這個協(xié)議，則可以通過擴展讓他遵守這個協(xié)議
2. 擴展可以給協(xié)議提供默認(rèn)實現(xiàn)，也間接實現(xiàn)「可選協(xié)議的效果」
3. 擴展可以給協(xié)議擴從「協(xié)議中從未聲明過的方法」

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

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

extension Person :TestProcotol{

}

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

//方法二：給協(xié)議擴展方法
extension BinaryInteger{
    func isOdd() -> Bool {
        self % 2 != 0
    }
}
print(5.isOdd())//輸出：true

protocol TestProcotol {
    func func1()
}

class Person :TestProcotol {
    //如果擴展中沒有實現(xiàn)，則必須實現(xiàn)協(xié)議中的方法 否則編譯報錯
    func func1() {
        print("PersonClass func1")
    }
    
    func func2() {
        print("PersonClass func2")
    }
}

//如果可以在協(xié)議擴展中實現(xiàn)或補充 繼承該協(xié)議的類可以不用實現(xiàn)協(xié)議中的方法
extension TestProcotol{
    func func1() {
        print("extension func1")
    }
    func func2() {
        print("extension func2")
    }
}

var person :TestProcotol = Person()
//func1在擴展中已經(jīng)實現(xiàn)
person.func1()//PersonClass func1
//func2在原協(xié)議中沒有
person.func2()//extension func2

疑問：為什么func2()輸出會不同呢？
如果person實例后面沒有加TestProcotol 則輸出為PersonClass func2 加了之后就是extension func2 因為原協(xié)議中沒有聲明func2，因此：
原協(xié)議中有的方法，優(yōu)先實例對象中實現(xiàn)的方法
原協(xié)議中沒有的方法，如果實例有聲明該協(xié)議，則優(yōu)先協(xié)議擴展中的方法；沒有聲明，優(yōu)先自己

泛型

• 擴展中依然可以使用原類型中的泛型類型
• 泛型符合條件才擴展

class Stack <Element>{
    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)//元素不符合 編譯報錯