class Country {
  let name: String
  // 注意这里：将 Country 的 capitalCity 属性声明为隐式解析可选类型的属性。这意味着像其他可选类型一样， capitalCity 属性的默认值为 nil ，但是不需要展开它的值就能访问它。
  var capitalCity: City!
  init(name: String, capitalName: String) {
    self.name = name
    self.capitalCity = City(name: capitalName, country: self)
  }
}

class City {
  let name: String
  unowned let country: Country
  init(name: String, country: Country) {
    self.name = name
    self.country = country
  }
}

// Country 的实例在给构造函数中给 name 属性赋完值后，整个初始化过程就完成了。 同时将 self 作为参数传递给  City 的构造函数
// capitalCity 属性能够被直接访问，不需要通过感叹号来展开它的可选值。
var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")
// Canada's capital city is called Ottawa

class HTMLElement {
  let name: String
  let text: String?
  // 闭包当中使用了 self，它捕获了 HTMLElement 的实例 text，并对 self 强引用
  // 虽然闭包多次使用 self，它只捕获 HTMLElement 实例的一个强引用
  lazy var asHTML: (Void) -> String = {
    if let text = self.text {
      return "<\(self.name)>\(text)</\(self.name)>"
    } else {
      return "<\(self.name) />"
    }
  }
  init(name: String, text: String? = nil) {
    self.name = name
    self.text = text
  }
  deinit {
    print("\(name) is being deinitialized")
  }
}

let heading = HTMLElement(name: "h1")
let defaultText = "some default text"
heading.asHTML = {
  return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
}
print(heading.asHTML())

// 实例的 asHTML 属性持有闭包的强引用，此时在闭包内部，闭包又强引用 self。造成循环强引用
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())

{ (parameters) -> returnType in
    statements
}

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

let reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
  return s1 > s2
})
// reversedNames 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 > s2 } )

reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )

reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )

reversedNames = names.sorted(by: { $0 > $1 } )

reversedNames = names.sorted(by: >)

func someFunctionThatTakesAClosure(closure: () -> Void) {
  // 函数体部分
}
// 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure(closure: {
  // 闭包主体部分
})
// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() {
  // 闭包主体部分
}

reversedNames = names.sorted() { $0 > $1 }

reversedNames = names.sorted { $0 > $1 }

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

// 无论你是将函数或闭包赋值给一个常量还是变量，实际上都是将常量或者变量的值设置为对应行数或者闭包的引用
let incrementByTen = makeIncrementor(forIncrement: 10)

incrementByTen() // 10
incrementByTen() // 20

// someFunctionWithEscapingClosure(_:)中的闭包是一个逃逸闭包，该闭包被添加到一个函数外定义的数组中。如果不显示将参数标记为 @escaping ，会得到编译错误
var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
  completionHandlers.append(completionHandler)
}

func someFunctionWithNonescapingClosure(closure: () -> Void) {
  closure()
}

class SomeClass {
  var x = 10
  func doSomething() {
    someFunctionWithEscapingClosure { self.x = 100 }
    someFunctionWithNonescapingClosure { x = 200 }
  }
}
let instance = SomeClass()
instance.doSomething()
print(instance.x) // 200

completionHandlers.first?()
print(instance.x) // 100

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count) // 5

// customerProvider 的类型不是 String，而是 () -> String
let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count) // 5

print("Now serving \(customerProvider())!") // "Now serving Chris!"
print(customersInLine.count) // 4

var customersInLine = ["Alex", "Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: () -> String) {
  print("Now serving \(customerProvider())!")
}
serve(customer: { customersInLine.remove(at: 0) } ) // Now serving Alex!

print(customersInLine) // ["Ewa", "Barry", "Daniella"]

var customersInLine = ["Alex", "Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: @autoclosure () -> String) {
  print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at: 0)) // Now serving Alex!
print(customersInLine) // ["Ewa", "Barry", "Daniella"]

var customersInLine = ["Alex", "Ewa", "Barry", "Daniella"]
var customerProviders: [() -> String] = []
func collectCustomerProviders(_ customerProvider: @autoclosure @escaping () -> String) {
  customerProviders.append(customerProvider)
}
collectCustomerProviders(customersInLine.remove(at: 0))
collectCustomerProviders(customersInLine.remove(at: 0))
print("Collected \(customerProviders.count) closures.") // Collected 2 closures.
for customerProvider in customerProviders {
  print("Now serving \(customerProvider())!")
}
// Now serving Alex!
// Now serving Ewa!

print(customersInLine) // ["Barry", "Daniella"]

class IntegerRef: Equatable {
  let value: Int
  init(_ value: Int) {
    self.value = value
  }

  static func == (lhs: IntegerRef, rhs: IntegerRef) -> Bool {
    return lhs.value == rhs.value
  }
}

let a = IntegerRef(100)
let b = IntegerRef(100)

print(a == a, a == b, separator: ", ")
// Prints "true, true"

let c = a
print(a === c, b === c, separator: ", ")
// Prints "true, false"

class Student: NSCopying {
  var name: String
  // required 只能修饰类初始化方法，当子类初始化方法与父类的不同，子类必须实现初始化方法，并且要使用 required 而不是 overide
  required init(name: String) {
    self.name = name
  }
  func copy(with zone: NSZone? = nil) -> Any {
    let student = Student(name: self.name)
    return student
  }
}

let stu1 = Student(name: "JY")
let stu2 = stu1.copy() as! Student

// false
ObjectIdentifier(stu1) == ObjectIdentifier(stu2)
stu2.name = "YU"

// JY
stu1.name
// YU
stu2.name

class Student{
  @objc static let describe = "class description"
  @objc class func getDefaultValue() -> Int {
    return 100
  }
}

func getDefaultValue(_ c: AnyClass) -> Int? {
  return c.getDefaultValue?()
}
func getDescribeValue(_ c: AnyClass) -> String? {
  return c.describe
}

// ptional(100)
print(getDefaultValue(Student.self))
// Optional("class description")
print(getDescribeValue(Student.self))

protocol SomeDelegate {
}

class SomeClass: SomeDelegate{
}

let instance = SomeClass.self
func isSomeDelegate(_ type: AnyClass) -> Bool{
  if type is SomeDelegate.Type{
    return true
  }
  return false
}

// true
print(isSomeDelegate(instance))

struct Person {
  let name: String
  let age: Int
}

let xiaoMing = Person(name: "XiaoMing", age: 16)
let r = Mirror(reflecting: xiaoMing)

print("属性个数:\(r.children.count)")
// 通过 Mirror 初始化得到的结果中包含的元素的描述都被集合在 children 属性下
// 其类型是 `public typealias Children = AnyCollection<Mirror.Child>`
for i in r.children {
  print("属性名:\(i)")
}
/*
 属性名:(Optional("name"), "XiaoMing")
 属性名:(Optional("age"), 16)
 */

// 也可以通过 `dump` 快速输出某个对象
dump(xiaoMing)
/*
 ▿ Person
 - name: "XiaoMing"
 - age: 16
 */

func valueFrom(object: Any, key: String) -> Any? {
  let mirror = Mirror(reflecting: object)

  for i in mirror.children {
    let (targetKey, targetMirror) = i
    if key == targetKey {
      return targetMirror
    }
  }

  return nil
}

if let name = valueFrom(object: xiaoMing, key: "name") as? String {
  print("通过 key 得到值: \(name)")
}

extension UIButton{
  class func swipButtonAction(){
    struct T {
      static var swizzle: Bool = {
        let cls: AnyClass = UIButton.self

        let originalSelector = #selector(UIButton.sendAction(_:to:for:))
        let swizzleSelector = #selector(UIButton.swizzle_sendAction(action:to:forEvent:))

        let origin_method = class_getInstanceMethod(cls, originalSelector)
        let swizzle_method = class_getInstanceMethod(cls, swizzleSelector)

        // 交换两个方法实现
        method_exchangeImplementations(origin_method, swizzle_method)

        return false
      }()
    }

    _ = T.swizzle
  }

  // 定义要交换的函数
  public  func swizzle_sendAction(action: Selector,
                                  to: AnyClass!,
                                  forEvent: UIEvent!){
    // 累加器
    struct button_tap_count{
      static var count = 0
    }

    button_tap_count.count += 1
    print(button_tap_count.count)
    // 看似好像调用了自己构成死循环,但是 我们其实已经将两个方法名的实现进行了调换 所以 其实我们调用的是 方法sendAction:to:forEvent 的实现 这样就可以在不破环原先方法结构的基础上进行交换实现
    swizzle_sendAction(action: action, to: to, forEvent: forEvent)
  }
}