public func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = default, file: StaticString = #file, line: UInt = #line)

public func assertionFailure(_ message: @autoclosure () -> String = default, file: StaticString = #file, line: UInt = #line)

public func precondition(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = default, file: StaticString = #file, line: UInt = #line)

func swapTwoValues<T>(inout a: T, inout b: T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
    // function body goes here
}

protocol WeightCalculable {
    // 属性重量根据不同体积返回的可能是Int，可以可能是double类型，所以使用别名, 协议中使用associatedtype关键词，
    associatedtype WeightType
    var weight: WeightType {  get  }
}

extension Int {
    typealias Weight = Int
    var t: Weight {return self * 1_000}
}

class iPhone: WeightCalculable {
    typealias WeightType = Double
    var weight: WeightType {
        return 0.5
    }
}

class Car: WeightCalculable {
    typealias WeightType = Int
    let weight: WeightType
    
    init(weight: Int) {
        self.weight = weight
    }
}

let bigCar = Car(weight: 8_000.t) // 8 吨

protocol Recordable: CustomStringConvertible {
    var wins: Int { get }
    var losses: Int { get }
    
    func winningPerent() -> Double
}

extension Recordable {
	// CustomStringConvertible 协议默认实现
    var description: String {
        return String(format: "WINS: %d---LOSSES: %d", [wins, losses])
    }
    
    // 默认实现总场数计算型属性
    var totalGames: Int {
        return wins + losses
    }
    
    // 默认实现的方法
    func shoutWins() {
        print("come on", wins, "times!")
    }
}

struct BasketballRecord:Equatable, Comparable, CustomStringConvertible, Recordable {
    var wins: Int
    var losses: Int
    
    
    /// 在具体定义的类型中实现 协议中的属性或者方法就会覆盖协议中的
    var totalGames: Int = 200
    
    var description: String {
        return "本次比赛胜: " + String(wins) + "负" + "\(losses)"
    }
    
    // 胜率
    func winningPerent() -> Double {
        return (Double(wins) / Double(totalGames))
    }
    
    // swift4.1 后，不需要再重写此方法，swift 会自动合成，如果不想让某一个属性参与比较，就需要重写该方法
    static func == (lhs: BasketballRecord, rhs: BasketballRecord) -> Bool {
        return lhs.wins == rhs.wins && lhs.losses == rhs.losses
    }
    
    // Comparable
    static func < (lhs: BasketballRecord, rhs: BasketballRecord) -> Bool {
        if lhs.wins != rhs.wins {
            return lhs.wins < rhs.wins
        }
        return lhs.losses > rhs.losses
    }
}
``` 

#### 足球比赛：

有平局的情况，原来的协议不能满足，需要增加一个平局的协议

- 定义平局协议

- 足球比赛需要遵守的协议 `Recordable` 和 `Tieable`

	- 总场数需要加上平局的场数，需要实现totalGames的get方法

- 足球比赛中以上写法存在的问题
	
	- 所有有平局的比赛计算总场次的逻辑都是一样，每次都要写一次实现
	- 单一修改 Recordable 协议不能解决问题，
	- 存在平局和没有平局两种情况 totalGames 的计算逻辑不相同 

- 解决办法：
	- 扩展遵守了`Recordable`协议的类型，前提条件是：这个类型遵守了 Tieable 同时也遵守了 `Recordable ` 协议，可以理解为如果该类型遵守了 `Tieable `协议之后，`Recordable` 协议中的 totalGames 属性实现是另一种方式了，不在是以前的 `totalGames` 中直接返回 `wins + losses` 的值
	

定义协议

协议默认实现

扩展遵守了Tieable 的 类型的 Recordable 协议

### 协议聚合

如果对某一类型需要限制他必须遵守某些协议，可以使用协议聚合来定义

比如： 有个奖赏协议

篮球比赛遵守此协议

足球比赛奖赏遵守此协议

现在有某一个学生也遵守了此协议

定义奖赏的方法，参数类型必须是遵守了此协议的结构或者类型

如果说 BasketballRecord 这个类还遵守了其他的协议，例如遵守了 `Recordable` 协议， 并且这个协议也遵守了 `CustomStringConvertible` 并且默认实现了`description` 的`get` 方法

`Recordable` 默认实现

此时如果 `Student` 类还是调用 `award` 方法的话，print(one) 打印的信息将是`Recordable `中默认实现的内容，因此需要约束`award`函数的参数必须遵守两个协议让`Student` 也重写自己的`description `属性的`get`方法，不能再让 `Prizable` 扩展 默认实现

- swift 3 写法： protocol<A, B>
- swift 4 写法： A & B

### 泛型约束


-  定义一个函数，找出一个学生数组中分数最大的
	- 参数：一个学生数组，都遵守了 Comparable 的类型
	- 返回值：某个遵守了 Comparable 的类型实例
   	- 此时函数报错 `Protocol 'Comparable' can only be used as a generic constraint because it has Self or associated type requirements`, 
   	
   	因为 Comparable 协议中定义的方法  public static func < (lhs: Self, rhs: Self) -> Bool 的参数类型是Self，是具体的某个类型

- 如果需要定义一个函数实现在一个数组中找出需要奖励的人的名字该如何实现呢
	- 参数：遵守两个协议 Comparable 和 Prizable 协议, 并且使用泛型
	- 返回值：返回值是可选值，有可能没有任何奖励的对象

struct Point {
    var x = 0.0
    var y = 0.0
    
}

struct Size {
    var height = 0.0
    var width = 0.0
}

struct Rectangle {
    var origin = Point()
    var size = Size()
    
    init(origin: Point, size: Size) {
        self.origin = origin
        self.size = size
    }
}

extension Rectangle {
    mutating func translate(x: Double, y: Double) {
        self.origin.x += x
        self.origin.y += y
    }
}

extension Rectangle {
    var center: Point {
        get {
            let center_x = origin.x + size.width / 2.0
            let center_y = origin.y + size.height / 2.0
            return Point(x: center_x, y: center_y)
        }
        
        set {
            origin.x = newValue.x - size.width / 2.0
            origin.y = newValue.y - size.height / 2.0
        }
    }
}

extension Rectangle {
    init(center: Point, size: Size) {
        let origin_x = center.x - size.width / 2.0
        let origin_y = center.y - size.height / 2.0
        self.origin = Point(x: origin_x, y: origin_y)
        self.size = size
    }
    
    // 结构体中不能扩展便利构造函数 Delegating initializers in structs are not marked with 'convenience'
//    convenience init(center: Point, size: Size) {
//        let origin_x = center.x - size.width / 2.0
//        let origin_y = center.y - size.height / 2.0
//        self.origin = Point(x: origin_x, y: origin_y)
//        self.size = size
//    }
}

extension Rectangle {
    enum Vertex: Int {
        case left_top
        case left_bottom
        case right_bottom
        case right_top
    }
    
    // 获取某一个顶点坐标
    func point(of vertex: Vertex) -> Point {
        switch vertex {
        case .left_top:
            return origin
        case .left_bottom:
            return Point(x: origin.x, y: origin.y + size.height)
        case .right_bottom:
            return Point(x: origin.x + size.width, y: origin.y + size.height)
        case .right_top:
            return Point(x: origin.x + size.width, y: origin.y)
        }
    }
}

extension Rectangle {
    subscript(index: Int) -> Point? {
        assert(0 <= index && index < 4, "传入值非法")
        return point(of: Vertex(rawValue: index)!)
    }
}

extension Int {
    /// 平方
    var square: Int {
        return self * self
    }
    
    /// 立方
    var cube: Int {
        return self * self * self
    }
    
    /// 判断数组是否在某一个范围内
    func inRange(clousedLeft left: Int, openRight right: Int) -> Bool {
        return self >= left && self > right
    }
    
    /// 重复执行操作
    func repeatitions(task: () -> ()) {
        for _ in 0..<self {
            task()
        }
    }
    
    /// 变长函数
    func stride(from: Int, to: Int, by: Int, task: () -> ()) {
        // 系统变长函数
        for i in Swift.stride(from: 0, to: 21, by: 3) {
            print(i)
        }
        
        for _ in Swift.stride(from: from, to: to, by: by) {
            task()
        }
    }
}

print(2.square)
print(3.cube)
print(4.inRange(clousedLeft: 0, openRight: 4))
4.repeatitions {
    print("extension")
}
    
    
// 使用变长函数
4.stride(from: 0, to: 8, by: 4) {
    print("stride")
}

struct Vector_3 {
    var x = 0.0
    var y = 0.0
    var z = 0.0
    
    // 根据索引获取
    subscript(index: Int) -> Double? {
        
        // 重写了get方法 实现通过下标获取属性值
        get {
            switch index {
            case 0: return x
            case 1: return y
            case 2: return z
            default: return nil
            }
        }
        
        // 重写 set 方法，实现g通过下标设置属性值，使用系统默认的newValue
        set {
            guard let newValue = newValue else {return}
            switch index {
            case 0: x = newValue
            case 1: y = newValue
            case 2: z = newValue
            default: return
            }
        }
    } 
    
    // 增加第二种下标--根据坐标轴获取属性值
    subscript(axis: String) -> Double? {
        
        get {
            switch axis {
            case "X", "x": return x
            case "Y", "y": return y
            case "Z", "z": return z
            default: return nil
            }
        }
        
        set {
            guard let newValue = newValue else {return}
            switch axis {
            case "X", "x": x = newValue
            case "Y", "y": y = newValue
            case "Z", "z": z = newValue
            default: return
            }
        }
    }
}

```    

### 下标访问

结构体使用下标获取值

结构体使用下标修改值

### 多维下标

定义一个关于矩阵的结构体

	struct Matrix {
	    var data: [[Double]]
	    let row: Int
	    let column: Int
	    
	    init(row: Int, column: Int) {
	        self.row = row
	        self.column = column
	        data = [[Double]]()
	        for _ in 0..<row {
	            let aRow = Array(repeating: 1.0, count: column)
	            data.append(aRow)
	        }
	    }
	    
	    // 通过下标 [row,column] 方式访问
	    subscript(row: Int, column: Int) -> Double {
	        get {
	            assert(row >= 0 && row < self.row && column >= 0 && column < self.column, "下标不合法")
	            return data[row][column]
	        }
	        
	        set {
	            assert(row >= 0 && row < self.row && column >= 0 && column < self.column, "下标不合法")
	            data[row][column] = newValue
	        }
	    }
	    
	    // 通过下标 [row][column] 方式访问
	    subscript(row: Int) -> [Double] {
	        get {
	            assert(row >= 0 && row < self.row, "下标不合法")
	            // 直接返回数组，数组本身有下标
	            return data[row]
	        }
	        
	        set {
	            assert(newValue.count == column, "下标不合法")
	            data[row] = newValue
	        }
	    }
	}

 
### 运算符重载
 
- 重载 + 运算符

- 两个参数时相减

- 一个参数时去反, 需要 prefix 修饰

- 向量相乘/向量和常量相乘

- 两个参数不能交换，需要重载两次 `*`

- 修改自身参数，不需要返回值

### 自定义操作符

`postfix` 声明前后缀关键词， `operator ` 操作符关键词

- a+++

- +++a

protocol Shakable {}
extension Shakable where Self: UIView {
    func shakeAnimation() {
        let animation = CABasicAnimation(keyPath: "position")
        animation.duration = 0.08
        animation.repeatCount = 5
        animation.autoreverses = true
        animation.fromValue = NSValue(cgPoint: CGPoint(x: self.center.x - 4, y: self.center.y))
        animation.toValue = NSValue(cgPoint: CGPoint(x: self.center.x + 4, y: self.center.y))
        layer.add(animation, forKey: "position")
    }
}

class MyButton: UIButton, Shakable {  }
class MySwitch: UISwitch, Shakable {  }
class MyTextField: UITextField, Shakable {  }

let mySwitch = MySwitch()
mySwitch.isOn = true
self.mySwitch = mySwitch
view.addSubview(mySwitch)
mySwitch.translatesAutoresizingMaskIntoConstraints = false
mySwitch.topAnchor.constraint(equalTo: view.bottomAnchor, constant: 10).isActive = true
mySwitch.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 10).isActive = true

// 调用
mySwitch.shakeAnimation()

protocol ReusableView: class {	}

extension ReusableView where Self: UIView {
    static var reuseIdentifier: String {
        return String(describing: self)
    }
}

``` 

### 对tableView扩展

### 用法

- 创建自定义的cell，需要遵守协议

- 注册和使用

enum Month: Int {
    case January = 1
    case February
    case March
    case April
    case May
    case June
    case July
    case August
    case September
    case October
    case November
    case December
}

enum Season: Int {
    case Spring = 1
    case Summer = 5
    case Autumn = 10
    case Winter = 40
}

enum ProgrammerLanguae: String {
    case Swift
    case OC = "Objective-C"
    case C = "语言"
    case RN = "React-Native"
    case Java
}

func residueNewYear(month: Month) -> Int {
    return 12 - month.rawValue
}

let month = Month(rawValue: 5)
let swift = ProgrammerLanguae.Swift.rawValue
let oc = ProgrammerLanguae.OC
let RN = ProgrammerLanguae.RN.rawValue

enum Status {
    case success(Int)
    case fail(String)
    case null // 未关联值
}

func associateValueTest(isSuccess: Bool) -> Status {
    if isSuccess {
        return .success(200)
    }
    return .fail("失败")
}

enum Shape {
    case Square(width: Double)
    case Reactangle(width: Double, height: Double)
    case Circle(x: Double, y: Double, radius: Double)
    case Point
}

let square = Shape.Square(width: 20)
let reactangle = Shape.Reactangle(width: 10, height: 20)
let circle = Shape.Circle(x: 10, y: 10, radius: 20)
let point = Shape.Point

private func area(shape: Shape) -> Double {
    switch shape {
    case let .Square(width):
        return width * width
    case let .Reactangle(width, height):
        return width * height
    case let .Circle(_, _, radius):
        return radius * radius * Double.pi
    case .Point:
        return 0
    }
}

indirect enum ArithmeticalExpression {
    case Number(Int)
    case Addition(ArithmeticalExpression, ArithmeticalExpression) // + 时两边也是一个表达式
    case Multiplication(ArithmeticalExpression, ArithmeticalExpression) // * 时两边也是一个表达式
    
//    indirect case Addition(ArithmeticalExpression, ArithmeticalExpression) // + 时两边也是一个表达式
//    indirect case Multiplication(ArithmeticalExpression, ArithmeticalExpression) // * 时两边也是一个表达式
}

let two = ArithmeticalExpression.Number(2)
let one = ArithmeticalExpression.Number(3)
let sum = ArithmeticalExpression.Addition(two, one)
let indirectEnumResult = ArithmeticalExpression.Multiplication(sum, ArithmeticalExpression.Number(4))

private func calculate(expression: ArithmeticalExpression) -> Int {
    switch expression {
    case let .Number(value):
        return value
    case let .Addition(left, right):
        return calculate(expression: left) + calculate(expression: right)
    case let .Multiplication(left, right):
        return calculate(expression: left) * calculate(expression: right)
    }
}

struct Location {
    var latitude: Double
    var longitude: Double
    var placeName: String?
}

let location1 = Location(latitude: 37.3230, longitude: -122.0322, placeName: "测试")

struct Location2 {
    var latitude: Double = 0
    var longitude: Double = 0
}

let location2 = Location2()

struct Location3 {
    let latitude: Double
    let longtitude: Double
    var placeName: String?
    
    init(coordinateString: String) {
        let index = coordinateString.index(of: ",")
        let index1 = coordinateString.index(after: index!)
        let test_1 = coordinateString.prefix(upTo: index!)
        let test_2 = coordinateString.suffix(from: index1)
        
        latitude = Double(test_1)!
        longtitude = Double(test_2)!
    }
    
    init(latitude: Double, longitude: Double, placeName: String?) {
        self.latitude = latitude
        self.longtitude = longitude
        self.placeName = placeName
    }
}

let test3 = Location3(coordinateString: "12,45")

class Father {
    var name: String
    var sex: Int = 0
    var old: Int = 32
    var desc: String {
        return "我是\(name)"
    }
    init(name: String) {
        self.name = name
    }
    
    init(name: String, old: Int) {
        self.name = name
        self.old = old
    }
    
    func run() {
        print("Father can Running")
    }
}

class Son: Father {
    var isSwimming = true
    var computer: String
    
    override var desc: String {
        return "Son is \(name)"
    }
    
    // 子类指定构造函数,调用了父类的指定构造函数
    init(name: String, computer: String) {
        self.computer = computer
        super.init(name: name)
    }
    
    // 子类便利构造函数，调用了指定构造函数
    convenience override init(name: String) {
        let computer = "iMac"
        self.init(name: name, computer: computer)
    }
}

class Father {
    var name: String
    var sex: Int = 0
    var old: Int = 32
    var desc: String {
        return "我是\(name)"
    }
    
    /// Father指定构造函数-1
    init(name: String) {
        self.name = name
    }
    
    /// Father指定构造函数-2
    init(name: String, old: Int) {
        self.name = name
        self.old = old
    }
    
    /// Father便利构造函数
    convenience init(old: Int) {
        self.init(name: "Father", old: old)
    }
    
    func run() {
        print("Father can Running")
    }
}

class Son: Father {
    var isSwimming = true
    var computer: String
    var job: String
    
    override var desc: String {
        return "Son is \(name)"
    }
    
    /// 子类重载的指定构造函数-1
    convenience override init(name: String) {
        self.init(name: name, computer: "Dell")
    }
    
    /// 子类重载的指定构造函数-2
    override convenience init(name: String, old: Int) {
        self.init(name: name, computer: "acer")
    }
    
    
    /// 子类自己的指定构造函数,调用了父类的指定构造函数
    init(name: String, computer: String) {
        self.computer = computer
        self.job = "C#"
        super.init(name: name)
    }
    
    // 子类便利构造函数，调用了自己指定构造函数
    convenience init(computer: String) {
        let name = "小张"
        self.init(name: name, computer: computer)
    }
}

class Grandson: Son {
    var toy: String = "dog toys"
}

let grandSon0 = Grandson(old: 4)
let grandSon1 = Grandson(computer: "Mi")
let grandSon2 = Grandson(name: "小王")
let grandSon3 = Grandson(name: "小虎", computer: "👽")
let grandSon4 = Grandson(name: "小李", old: 8)

let son0 = Son(old: 30)
let son1 = Son(computer: "Mi")
let son2 = Son(name: "小王")
let son3 = Son(name: "小虎", computer: "👽")
let son4 = Son(name: "小李", old: 8)

class Father {
    var name: String
    /// Father指定构造函数-1
    // required 修饰的指定构造函数子类中必须实现
    required init(name: String) {
        self.name = name
    }
}

class Son: Father {
    var isSwimming = true
    var computer: String
    
    /// 子类重载的指定构造函数-1
    convenience required init(name: String) {
        self.init(name: name, computer: "Dell")
    }
    
    /// 子类自己的指定构造函数,调用了父类的指定构造函数
    init(name: String, computer: String) {
        self.computer = computer
        self.job = "C#"
        super.init(name: name)
    }
}

class Son1: Son {
    var sport: String
    
    // 指定构造函数，需要调用父类的指定构造函数
    init(name: String, sport: String) {
        self.sport = sport
        Son.init(name: name)
    }
    
    // 父类中有被 required 关键词修饰的必须实现的构造函数
    convenience required init(name: String) {
       // fatalError("init(name:) has not been implemented")
        // 调用自己的指定构造函数，
        self.init(name: name, sport: "")
    }
}

The following build commands failed:
        CompileC /Users/liepin/LiePinWorkspace/RNDemo/GitHubPopular/ios/build/Build/Intermediates.noindex/RCTWebSocket.build/Debug-iphonesimulator/RCTWebSocket.build/Objects-normal/x86_64/RCTSRWebSocket.o RCTSRWebSocket.m normal x86_64 objective-c com.apple.compilers.llvm.clang.1_0.compiler
(1 failure)
Installing build/Build/Products/Debug-iphonesimulator/GitHubPopular.app
An error was encountered processing the command (domain=NSPOSIXErrorDomain, code=2):
Failed to install the requested application
An application bundle was not found at the provided path.
Provide a valid path to the desired application bundle.
Print: Entry, ":CFBundleIdentifier", Does Not Exist

Command failed: /usr/libexec/PlistBuddy -c Print:CFBundleIdentifier build/Build/Products/Debug-iphonesimulator/GitHubPopular.app/Info.plist
Print: Entry, ":CFBundleIdentifier", Does Not Exist

sudo rm -rf /usr/local/lib/node_modules/npm
brew reinstall node

#import <RCTAnimation/RCTValueAnimatedNode.h>

#import "RCTValueAnimatedNode.h"