Swift源码简单解读 - == 与 ??

==

==的定义地方有很多,也不能所有地方都进行解读,解读几个常见的吧

==在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))),而这种情况走的也是第二个函数