==
==的定义地方有很多,也不能所有地方都进行解读,解读几个常见的吧
==在array中的定义
@inlinable
public static func ==(lhs: Array<Element>, rhs: Array<Element>) -> Bool {
let lhsCount = lhs.count
if lhsCount != rhs.count {
return false
}
// Test referential equality.
if lhsCount == 0 || lhs._buffer.identity == rhs._buffer.identity {
return true
}
_internalInvariant(lhs.startIndex == 0 && rhs.startIndex == 0)
_internalInvariant(lhs.endIndex == lhsCount && rhs.endIndex == lhsCount)
// We know that lhs.count == rhs.count, compare element wise.
for idx in 0..<lhsCount {
if lhs[idx] != rhs[idx] {
return false
}
}
return true
}
官方定义如上
简单解读下
1.判断数组的count,不一样,则直接返回false
2.判断count是否为0,至于lhs._buffer.identity == rhs._buffer.identity 这段代码里的_buffer就是个_ArrayBuffer的实例,_ArrayBuffer是个内部结构体,官方定义是:
This is the class that implements the storage and object management for Swift Array.
所以不难看出是一个管理array内存的工具结构体,然后identity是它的指针,所以那段代码的意思既是判断内存地址是否一致,所以如果count为0或者地址一致,则直接返回true
3.如果前面两者都没判断出来则进入最后一步,逐一比对
var arr:[Int] = [1,2,3]
var arr1:[Int] = [1,2,3]
print(Mems.ptr(ofVal: &arr)) //0x000000010000c200
print(Mems.ptr(ofVal: &arr1)) //0x000000010000c208
print(arr == arr1) // true
所以这种地址不一样的也会比对成功,相对于只比较地址,这个比对无疑要人性化一点
==在Optional中的定义
==在Optional里面定义了三个,针对的是三种不同的调用方式
@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
}
}
@_transparent
public static func ==(lhs: Wrapped?, rhs: _OptionalNilComparisonType) -> Bool {
switch lhs {
case .some:
return false
case .none:
return true
}
}
public static func ==(lhs: _OptionalNilComparisonType, rhs: Wrapped?) -> Bool {
switch rhs {
case .some:
return false
case .none:
return true
}
}
从上到下分别是两边都是可选项,左边是可选项,以及右边是可选项,至于_OptionalNilComparisonType 官方定义是一个nil(Create an instance initialized with `nil)
然后有人会问了怎么没有两边都是 _OptionalNilComparisonType类型的,一个两边都是其它类型的运算关它可选项啥事
没啥好说的,学过可选项看代码都能看懂,不过值得一提的是
var v1: Int? = 1
var v2: Int?? = 1
print(v1 == v2) //true
这两个是true
??
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T)
rethrows -> T {
switch optional {
case .some(let value):
return value
case .none:
return try defaultValue()
}
}
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?)
rethrows -> T? {
switch optional {
case .some(let value):
return value
case .none:
return try defaultValue()
}
}
有两个定义,没啥好说的一半用于判断是否有值,没有设置默认值这种场合,看代码也能看懂,但值得一提的是
var v :Int???? = nil
print(v ?? 10) //Optional(Optional(Optional(10)))
会把10包装成????四个可选项的包装,然后里面只解了单层,所以是Optional(Optional(Optional(10))),而这种情况走的也是第二个函数