Swift - 4 可选项Optional、运算符重载及自定义

海的天空1661

已于 2023-01-28 11:56:52 修改

阅读量145

点赞数

分类专栏： swift 文章标签： swift

于 2021-05-11 15:54:34 首次发布

原文链接：https://df.com

版权

swift 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

可选项

可选项，一般也可叫做可选类型。他允许讲值设置为nil

在类型名称后面加个问好？来定义一个可选项

var name: String? = "jac"
name = nil

var age: Int? // 默认就是nil
age = 10
age = nil

var array = [1, 2, 3, 44]
func get(_ index: Int) -> Int? {

    if index < 0 || index >= array.count {
        return nil
    }
    return array[index]
}

print(get(1))  // Optional(2)
print(get(-1)) // nil
print(get(4))  // nil

强制解包 Forced Unwrapping

可选项是对其他类型的一层包装，可以将它理解为是一个盒子

如果为nil，那么它就是一个空盒子

如果不为nil，那么盒子里装的是：被包装类型的数据

如果要从可选项中取出被包装的数据（将盒子里的东西取出来），需要使用感叹号！进行强制解包

var age: Int? = 10
var ageInt: Int = age!
ageInt += 10

如果对值为nil的可选项（空盒子）进行强制解包，将会产生运行时错误

判断可选项是否包含值

var age = Int("122")
if age != nil {
    print("有值")
} else {
    "nil"
}

可选项绑定Optional Binding

可以使用可选项绑定来判断可选项是否包含值

如果包含就自动解包，把值赋给一个临时的常量let或者变量var，并返回true，否则返回false.

if let age = Int("122") {
    print("转换成功") // age是枪直接报之后的Int值， age的作用于仅限于这个大括号内
} else {
    "转换失败"
}


enum Season: Int {
    case spring = 1, summer, autumn, winter
}

if let season = Season(rawValue: 6) {
    switch season {
    case .spring:
        "sping"
    default:
        "ohter"
    }
} else {
    "失败，没有season"
}

if的判断可简写下面两种写法等价

if let first = Int("23") {
    if let secont = Int("333") {
        if first < secont && secont < 400 {
            print("\(first) < \(secont) < 100")
        }
    }
}

if let first = Int("23"),
   let secont = Int("333"),
   first < secont && secont < 400 {
    print("\(first) < \(secont) < 100")
    
}

While循环中使用可选项绑定，如果包含也是自动解包

// 遍历数组，将遇到的正数都加起来，如果遇到负数或者非数字，停止遍历

var  strs = ["10", "20", "30", "xss", "-30", "22"]

var index = 0
var sum = 0
while let num = Int(strs[index]), num > 0 {
    sum += num
    index += 1
}
print(sum)

空合并运算符 ?? (Nil-Coalescing Operator)

public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T?

a ?? b

条件：a是可选项 && b是可选项或者不是可可选项 && b 跟a的存储类型必须相同

如果a不为nil，就返回a

如果a为nil，就返回b

如果b不是可选项，返回a时会自动解包

多个 ?? 一起使用就看最后一个值是什么类型

let a: Int? = 1
let b: Int? = 2
let c = a ?? b ?? 3 // c是Int 1

let a: Int? = nil
let b: Int? = 2
let c = a ?? b ?? 3 // c是Int 2

let a: Int? = nil
let b: Int? = nil
let c = a ?? b ?? 3 // c是Int 3

?? 和 if let 配合使用

字符串插值

可选项在字符串插值或者直接打印时，编译器会发出警告

let a: Int? = 1
print("My age is \(a)")

至少有3中解除警告的方法

guard语句

隐式解包Implicitly Unwrapped Optional

在某些情况下，可选项一旦被设定值之后，就会一直拥有值

在这种情况下，可以去掉检验，也不必每次访问的时候都进行解包，因为它能确定每次访问的时候都有值。可以在类型后面加个感叹号！定义一个隐式解包的可选项

（一般情况下，不怎么用这个隐式解包的形式，除非你希望别人传给你的是确定有值的，一把都可以用可选的来处理）

let a: Int! = 1

看下面的几种nil的情况

可选项的本质

可选项的本质是enum类型

@frozen 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
age3 = .none

var age: Int? = nil
var age0 = Optional<Int>.none
var age1: Optional<Int> = .none

var age: Int? = .none
age = nil
// 看出上面和下面的等同写法
age = 10
age = .some(30)


switch age {
case let v?:
    print("some", v)
case nil:
    print("none")
}

switch age {
case let .some(v)
    print("some", v)
case nil:
    print("none")
}

溢出运算符 Overflow Operator

Swift的算术运算符出现溢出时会抛出运行时错误

Swift有溢出运算符(&+、&-、&*)，来支持溢出运算

类、结构体、枚举可以为现有的运算符提供自定义的实现，这个操作叫做：运算符重载

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)
    }
}

Equatable

要想得知2个实例是否等价，一般的做法是遵守Equatable协议，重载 == 运算符，与此同时，等价于重载了 != 运算符

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

Swift为一下类型提供了默认的Equatable的实现：1：没有关联类型的枚举，2：只拥有遵守Equatable协议关联类型的枚举，3：只拥有遵守Equatable协议存储属性的结构体

引用类型比较存储的地址值是否相等（是否引用着同一个对象），使得恒等运算符 ===、 !==

Comparable

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)
    }
}

想要比较2个实例的大小，一般做法是：

遵守Comparable协议、重载相应的运算符

var stu1 = Student(score: 100, age: 20)
var stu2 = Student(score: 90, age: 18)
var stu3 = Student(score: 100, age: 20)
print(stu1 > stu2) // true
print(stu1 >= stu2) // ture
print(stu1 >= stu3) // true
print(stu1 <= stu3) // true
print(stu2 < stu1) // true
print(stu2 <= stu1) // true

自定义运算符，在全局作用域使用operator进行声明