1.Optional源码分析和使用
1.1.Optional源码
public enum Optional<Wrapped>: ExpressibleByNilLiteral {
case none
case some(Wrapped)
@_transparent
public init(_ some: Wrapped) { self = .some(some) }
@inlinable
public func map<U>(
_ transform: (Wrapped) throws -> U
) rethrows -> U? {
switch self {
case .some(let y):
return .some(try transform(y))
case .none:
return .none
}
}
Optional的本质是enum，所以下面的三种方式写法是一样的效果
var age1:Int? = 10
var age2:Optional<Int> = .some(10)
var age3 = Optional(10)
1.2.Optional解包
1.switch解包
var age:Int? = 10
switch age {
case .none:
print("nil")
case .some(let x):
print("\(x)")
}
2.强制解包
var age:Int? = 10
print(age!)
如果age为nil，报错 Unexpectedly found nil while unwrapping an Optional value
当我们用！，我们对optional实例有充分的自信，相信该实例一定有值，
3.if let和gurad let解包
var age:Int? = nil
if let temp = age {
print(temp)
} else {
print("nil")
}
当age为nil时，走else，当age有值时打印age的值.
当我们使用guard解包时
guard let temp = age else{
print("空值")
return
}
print(temp)
可以看到 gurad 后⾯的判断条件为 false 的时候会执⾏当前⼤括号⾥⾯的内容，反之执⾏后⾯的代码。
总结
我们在使⽤ if let 创建的内容当中 unWrappedValue 仅仅只能在当前 if 分⽀的⼤括号内访问到，⽽我们当前的 guard 定义的 unWrappedValue 在当前⼤括号外部也是能访问到的
2.Equatable
我们在optional类型使用==
var age1 :Int? = 10
var age2:Int? = 10
print(age1 == age2)
打印结果为true，为什么呢？我们看源码
extension Optional: Equatable where Wrapped: Equatable {
@inlinable
public static func ==(lhs: Wrapped?, rhs: Wrapped?) -> Bool {
switch (lhs, rhs) {
case let (l?, r?):
return l == r
case (nil, nil):
return true
default:
return false
}
}
}
在optional的extension中重载了Equatable的方法
我们的定义的结构体==呢
struct PWTeacher:Equatable {
var age:Int
var name:String
}
var t = PWTeacher(age: 18, name: "pw")
var t1 = PWTeacher(age: 18, name: "pw")
print(t == t1)
我们自定义的结构体要遵守Equatable协议，我们才可以使用==
打印为true。我们看sil，看编译器做了怎样的处理
struct PWTeacher : Equatable {
@_hasStorage var age: Int { get set }
@_hasStorage var name: String { get set }
init(age: Int, name: String)
@_implements(Equatable, ==(_:_:)) static func __derived_struct_equals(_ a: PWTeacher, _ b: PWTeacher) -> Bool
}
__derived_struct_equals的实现就是分别对比age和name，如果相等则返回true，否则返回false。
如果我们把结构体换成class呢，我们必须自己实现 static func ==，
class PWTeacher:Equatable {
var age:Int
var name:String
init(age:Int,name:String) {
self.age = age
self.name = name
}
static func == (lhs: PWTeacher, rhs: PWTeacher) -> Bool {
return lhs.age == rhs.age && lhs.name == rhs.name
}
}
var t = PWTeacher.init(age: 18, name: "pw")
var t1 = PWTeacher.init(age: 18, name: "pw")
print(t == t1)
打印结果是true
===
用来验证是不是同一个实例对象
var t = PWTeacher.init(age: 18, name: "pw")
var t1 = PWTeacher.init(age: 18, name: "pw")
var t2 = t
print(t === t1)
print(t2 === t)
打印结果，第一个是false第二个是true.
3.访问控制
3.1private
访问级别仅在当前定义的作⽤域内有效
class PWTeacher {
private var name:String = "PW"
func test() {
print(name)
}
}
var t = PWTeacher()
t.test()
t.name
当我们访问t.name时，
我们在单利时，使用private
class PWTeacher {
static let sharedInstance = PWTeacher()
private init(){}
}
我们使用PWTeacher，只能允许sharedInstance调用实例变量，我们无法使用inint进行初始化实例变量。
3.2 filePrivate:
此访问限制仅限制在当前定义的源⽂件中
fileprivate class PWPartTeacher:PWTeacher {
var age:Int = 18
}
func test() {
var t =PWPartTeacher()
t.age = 20
}
在其他文件不能访问PWPartTeacher
3.3Internal:
默认访问级别, 允许定义模块中的任意源⽂件访问，但不能被该模块之外的任 何源⽂件访问
这⾥的模块指的是:⼀个框架或者是应⽤程序。这⾥主要指的是通过 import 关键字导⼊的模块。
3.4 public
public修饰的类可以被其他模块访问但不能被继承或者重写，可以被本模块继承重写。和Internal区别是，public可以被其他模块访问，而Internal不能。和Open的区别是，open可以被其他模块继承重写而public不能。
3.5Open
最不受限制的访问级别
