Swift中Optional & 访问控制权限

• Optional

1. Swift中Optional本质：一个带泛型参数的enum。

@frozen public enum Optional<Wrapped> : ExpressibleByNilLiteral {

    /// The absence of a value.
    ///
    /// In code, the absence of a value is typically written using the `nil`
    /// literal rather than the explicit `.none` enumeration case.
    case none

    /// The presence of a value, stored as `Wrapped`.
    case some(Wrapped)

    ...
}

下面两种写法本质上是一样的：

var age : Int? = 20
var age1 : Optional<Int> = Optional<Int>.some(20)

2. 模式匹配：

switch age {
    case .none:
        print("nil")
    case .some(20):
        print(20)
    default : //.some(其他值)
        print("unKnown")
}

3. 解包：可选项是对当前值进行包装，所以值不为nil时需要拿出值。

• 强制解包（不推荐）：变量+!，如果值为nil强制解包就会导致程序崩溃。
• unsafelyUnwrapped属性：在Debug模式下且Optimization Level为不优化（-Onone）时，和强制解包是一样的，值为nil会崩溃；如果在Release模式下，优化后如果值为nil直接将值视为0.
• if let / guard let: 通过可选项绑定的方式判断当前可选项是否有值。
• ??：使用空运算符，返回值取决于??后面的类型（后面是可选类型，返回也是可选类型）

// if let：value的作用域在{ }内，{ }外访问不到
if let value = age {
    print("value : \(value)")
} else {
    print("age 为nil")
}

// guard let ：value在 { } 外也能访问
guard let value = age else {
        print("age 为nil")
        return
    }
print(value)

print(age ?? 30) //30

4.Equatable协议：Swift中的类型，在遵循该协议后使用==和!=来判断值相等还是不相等；Optional的扩展也遵循了该协议。

var age : Int? = 30
var age1 : Optional<Int> = Optional<Int>.some(20)

var isEqual = age == age1
print(isEqual) //false

如果想要自定义的类型也能通过==和!=来判断值相等还是不相等的话，就需要自定义的类型遵循Equatable协议：

struct YYTeacher : Equatable {
    var age : Int = 10
    var name : String = "YY"
}

var t = YYTeacher()
var t1 = YYTeacher(age: 10, name: "YY")
print(t == t1)  //true

遵循该协议后，SIL文件中自动生成该方法：

struct YYTeacher : Equatable {
  @_hasStorage @_hasInitialValue var age: Int { get set }
  @_hasStorage @_hasInitialValue var name: String { get set }
  @_implements(Equatable, ==(_:_:)) static func __derived_struct_equals(_ a: YYTeacher, _ b: YYTeacher) -> Bool
  init()
  init(age: Int = 10, name: String = "YY")
}

如果是class的话，遵循该协议后还需自己实现==方法：

class YYTeacher : Equatable {
    static func == (lhs: YYTeacher, rhs: YYTeacher) -> Bool {
        return lhs.age == rhs.age && lhs.name == rhs.name
    }
    
    var age : Int
    var name : String
    
    init(_ age : Int, _ name : String) {
        self.age = age
        self.name = name
    }
}

注意：Swift中比较两个值是否相等用==，如果要比较两个对象是否相等需用===:

var t = YYTeacher(20, "UU")
var t1 = t
t1.age = 30
var t2 = YYTeacher(20, "UU")

print(t === t1) //true
print(t === t2) // false

扩展：

• Comparable协议默认遵循了Equatable协议，Comparable里面包括<、<=、>、>=等运算符。
• 用as?类型转换时：
  转换成功 -->可选类型Optional(值)
  转换失败-->nil

• 访问控制权限

1. private'：访问级别仅在当前作用域`内有效

上面的age在它{ }的作用域外就不能被访问到。

2. fileprivate：仅在当前定义的源文件中可访问

错误访问：上面的常量y在未加任何访问控制权限时是默认权限internal，而YYTeacher的访问控制权限是fileprivate ；这里接收(y)权限internal > 访问(YYTeacher)权限fileprivate，所以报错。

正确访问如下：

fileprivate class YYTeacher {
    var age : Int = 10
}

fileprivate let y = YYTeacher()
// 或者 private let y = YYTeacher()

3. internal：默认权限，允许定义模块（框架或者APP，主要指import关键字导进来的模块）中的任何源文件访问，不允许之外的模块访问。
4. public：开放式访问，允许外部访问，但只能在定义的模块中继承和重写。
5. open：不受限制的访问级别，可在任何地方访问、继承和重写。