Swift十四(一: 可选项本质, 二: 运算符, 三: 扩展,

一: 可选项本质
二: 溢出运算符
三: 运算符重载
四: Equatable协议
五: Comparable协议
六: 自定义运算符
七: 扩展(Extension)

一: 可选项本质

截屏2022-07-13 10.50.32.png
截屏2022-07-13 10.50.37.png

二: 溢出运算符

截屏2022-07-13 14.16.50.png

 var min = UInt8.min // 0
 var max = UInt8.max  // 255
 print(min &- 1) // 255
 print(max &+ 1) // 0

//  print(min - 1) 
//  Arithmetic operation '0 - 1' (on type 'UInt8') results in an overflow 
//  算术运算“0-1”（在类型“UInt8”上）导致溢出

总结:
超出执行循环标准, 例如min当前为0, 再-1则溢出, 值为255

三: 运算符重载

截屏2022-07-13 14.49.23.png
截屏2022-07-13 14.49.31.png

struct Point {
    var x = 0
    var y = 0
    static func + (p1: Point, p2: Point) -> Point { // 默认中缀运算符
        Point(x: p1.x + p2.x, y: p2.y + p1.y)
    }
    static prefix func - (p: Point) -> Point { // 前缀运算符
        Point(x: -p.x, y: -p.y)
    }
    static postfix func ++ (p: inout Point) -> Point { // 后缀运算符
        p = Point(x: p.x + 1, y: p.y + 1)
       return  p
    }
}
    override func viewDidLoad() {
        super.viewDidLoad()
        let point1 = Point(x: 0, y: 1)
        let point2 = Point(x: 1, y: 1)
        let point3 = point1 + point2 //  Point(x: 1, y: 2)
        var point4 = -point3 // Point(x: -1, y: -2)
        point4++ // point4为 Point(x: 0, y: -1)
    }
}

总结:
作用: 为已经存在的运算符, 增加新的功能, 其实就是添加一个运算符名称的方法
现有运算符"+" "-" 等
图一: 为结构体Point 新重载一个 "+"运算, 可以两个结构体相加, static 编译器提示必须加

四: Equatable协议

截屏2022-07-13 15.45.14.png

public protocol Equatable {
    /// Returns a Boolean value indicating whether two values are equal. 
    /// 返回一个布尔值，指示两个值是否相等。
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// 平等是不平等的反义词。对于任何值“a”和“b”，
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    static func == (lhs: Self, rhs: Self) -> Bool
}

总结:
作用: 判断两个对象是否相等的协议, 可以调用==来判断两个对象是否相等
1 没有关联类型的枚举, 默认可以使用 == 判断相等
2 关联类型枚举, 遵守Equetable协议, 在使用 == 判断相等
3 结构体, 枚举 内部成员变量需要, 都遵守Equatable协议, 结构体可以直接遵守协议, 否则需要内部添加== 的实现
4 === 判断两个对象地址用的, 仅限于引用类型(类)

五: Comparable协议

// swift 中 Comparable协议定义, 默认还遵守了Equatable协议
public protocol Comparable : Equatable {

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is less than that of the second argument.
    ///
    /// This function is the only requirement of the `Comparable` protocol. The
    /// remainder of the relational operator functions are implemented by the
    /// standard library for any type that conforms to `Comparable`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    static func < (lhs: Self, rhs: Self) -> Bool

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is less than or equal to that of the second argument.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    static func <= (lhs: Self, rhs: Self) -> Bool

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is greater than or equal to that of the second argument.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    static func >= (lhs: Self, rhs: Self) -> Bool

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is greater than that of the second argument.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    static func > (lhs: Self, rhs: Self) -> Bool
}

截屏2022-07-13 16.04.24.png

总结:
作用: 比较两个对象大小的协议, 需要实现标准库中声明的四个方法

六: 自定义运算符

截屏2022-07-13 16.49.33.png
截屏2022-07-13 16.49.49.png

   override func viewDidLoad() {
        super.viewDidLoad()
        var p = Point(x: 2, y: 3)
        print(+++p) // Point(x: 4, y: 6)
        let p1 = Point(x: 3, y: 2)
        let p2 = Point(x: 1, y: 2)
        let p3 = p1 +- p2
        print(p3) //  Point(x: 4, y: 0)
    }
// 声明优先级组
precedencegroup myGroup {
    associativity: none // 结合性, 不能a +- b +- c 这样连着写
    higherThan: AdditionPrecedence // 比加法优先级高
    lowerThan: MultiplicationPrecedence // 比乘法优先级低
    assignment: true //等同于可选链中的 "="  p?.age = getInt() p是nil, getInt方法不调用
}
// 声明 自定义运算符
prefix operator +++
infix operator +-: myGroup // 只有中缀运算符需要声明优先级

struct Point {
    var x = 0
    var y = 0
    static prefix func +++ (p: inout Point) -> Point { // 自定义前缀运算符
        p = Point(x: p.x + p.x, y: p.y + p.y)
        return p
    }
    static func +- (left: Point, right: Point) -> Point { // 自定义中缀运算符
        return Point(x: left.x + right.x, y: left.y - right.y)
    }
}

总结:

1. 重载运算符: 重写现有的运算符
2. 自定义运算符: 新增一个自定义运算符
3. 定义中缀运算符, 需要指定参数运算符的优先级及结合性等

七: 扩展(Extension)

1 定义

截屏2022-07-14 09.23.07.png

2 扩展-添加计算属性 下标 枚举

截屏2022-07-14 09.30.58.png

• Double添加计算属性
• Array 添加下标
• Int 添加平方方法, 定义枚举, 计算属性
• 扩展添加 计算属性, 下标, 枚举

补充
1 . 添加存储属性, 是存储在对象中的, 会破坏内存结构
2 . 不能覆盖原有的方法, 和oc分类不一样
3 . 不能添加父类, 会继承父类的存储属性, 破坏内存结构
4 . dinit init 不能写, 便捷初始化器可以
5 . 默认情况下，实例方法中是不可以修改值类型的属性，使用mutating后可修改属性的值

3 扩展- 遵守协议 添加便捷初始化器

截屏2022-07-14 09.41.36.png

• 分类定义便捷初始化器
• 结构体 保留了默认初始化器, 又增加了新的初始化器

截屏2022-07-14 09.50.42.png

• 类通过扩展遵守协议
• 协议本身添加扩展, 新增方法

4 扩展- 协议添加扩展

截屏2022-07-14 10.02.20.png

• 可选协议效果: 默认协议声明方法, 遵守协议类需要实现其声明方法, 如果协议扩展实现了声明方法, 则遵守协议类, 可以不用添加方法实现

5 扩展- 涉及泛型

截屏2022-07-14 10.07.49.png

• 扩展可以使用类中定义的泛型
• 扩展可以添加条件判定语句