Swift5.x入门21--标准库源码分析，项目实战

Swift源码简介

• Swift于2015年开源，GitHub地址为：https://github.com/apple/swift
• 源码的常见目录：
  • docs：文档；
  • stdlib：Swift源码；
  • lib：C++源码；
  • include：C++头文件；

Array分析

• map，filter，flatMap，reduce，compactMap
• 在swift-main/stdlib/core中搜索 func xxx

public func map(_ transform: (Element) throws -> T) rethrows -> [T] {
      let initialCapacity = underestimatedCount
      var result = ContiguousArray()
      result.reserveCapacity(initialCapacity)

      var iterator = self.makeIterator()

      // Add elements up to the initial capacity without checking for regrowth.
      for _ in 0..

public func _filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element] {

      var result = ContiguousArray()
      var iterator = self.makeIterator()

      while let element = iterator.next() {
        if try isIncluded(element) {
          result.append(element)
        }
      }
      return Array(result)
 }

public func flatMap(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] {
      var result: [SegmentOfResult.Element] = []
      for element in self {
        result.append(contentsOf: try transform(element))
      }
      return result
}

 public func reduce(
    _ initialResult: Result,
    _ nextPartialResult:
      (_ partialResult: Result, Element) throws -> Result
  ) rethrows -> Result {
    var accumulator = initialResult
    for element in self {
      accumulator = try nextPartialResult(accumulator, element)
    }
    return accumulator
  }

@inlinable // protocol-only
  public func compactMap(
    _ transform: (Element) throws -> ElementOfResult?
  ) rethrows -> [ElementOfResult] {
    return try _compactMap(transform)
  }

  // The implementation of compactMap accepting a closure with an optional result.
  // Factored out into a separate function in order to be used in multiple
  // overloads.
  @inlinable // protocol-only
  @inline(__always)
  public func _compactMap(
    _ transform: (Element) throws -> ElementOfResult?
  ) rethrows -> [ElementOfResult] {
    var result: [ElementOfResult] = []
    for element in self {
      ///可选项绑定 筛选出nil
      if let newElement = try transform(element) {
        result.append(newElement)
      }
    }
    return result
  }

Optional分析

• map，flatMap，==，??

public func map(_ transform: (Wrapped) throws -> U) rethrows -> U? {
      switch self {
      case .some(let y):
        return .some(try transform(y))
      case .none:
        return .none
      }
}

public func flatMap(_ transform: (Wrapped) throws -> U? ) rethrows -> U? {
    switch self {
    case .some(let y):
      return try transform(y)
    case .none:
      return .none
    }
}

    // (age1? == age2?)
    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
      }
    }
    // (age? == nil)
    public static func ==(lhs: Wrapped?, rhs: _OptionalNilComparisonType) -> Bool {
      switch lhs {
      case .some:
        return false
      case .none:
        return true
      }
    }
    
    // (nil == age?)
    public static func ==(lhs: _OptionalNilComparisonType, rhs: Wrapped?) -> Bool {
      switch rhs {
      case .some:
        return false
      case .none:
        return true
      }
    }

public func ?? (optional: T?, defaultValue: @autoclosure () throws -> T)
    rethrows -> T {
  switch optional {
  case .some(let value):
    return value
  case .none:
    return try defaultValue()
  }
}

Metadata元型

• Metadata存储的是类(类型)的信息，以前分析swift实例对象的内存布局，可以知道实例对象的堆空间地址的前8个字节存储的是Metadata的内存地址；
• https://github.com/apple/swift/blob/main/docs/ABI/TypeMetadata.rst

反射

• 反射是编程语言中一项强大的能力，比如java语言的反射机制；
• 对于任意一个类型，都能动态的获取这个类的所有属性和方法信息；
• 对于任意一个实例，都能动态调用它的任意方法和属性；

import Foundation

class Person {
    var age: Int = 0
    var name: String = ""
    init(age: Int,name: String) {
        self.age = age
        self.name = name
    }
}

var person: Person = Person(age: 20, name: "liyan")

let mirror = Mirror(reflecting: person)

print(mirror.displayStyle)
print(mirror.subjectType)
print(mirror.superclassMirror as Any)

for case let (label?,value) in mirror.children {
    print(label,value)
}