Closure

基本函数

    //1. 参数包含 InnerName , ExternalName , 可以只写一个参数，
    //可以给予默认值， 但必须从右到左
    func name(externalName innerName: String) {

    }

    func name1(innerName: String) {

    }

    func name2(first: String, Second: String = "") {

    }

    name2(first: "hello")

函数签名是不包含参数名

    func methodSign(first: String, Second: String) {

    }

    func methodSign1(first: String, Second: String) {

    }

    func checkSign(funcSign: (String, String) -> ()) {

    }

    checkSign(funcSign: methodSign)
    checkSign(funcSign: methodSign1)

函数式作为一等公民，可以当做变量，返回值，参数，这提升了到函数编程的思想

Closure的简化版本, Closure 可以看做是包含上下文的函数

//标准版本
    let closureExpression = { (first: Int, second: Int) -> Int in
        return first + second
    }
    //a. 可以自己推导
    let _ = { (first: Int, second: Int) in
        return first + second
    }
    //b. 如果只有一条语句，可以去掉return
    let _ = { (first: Int, second: Int) in
        first + second
    }
    //c. 可以去掉参数
    var array = [3, 4, 2, 4]
    array.map({ String($0) })

    //d.如果是最后一个，可以把Closure放到后面
    array.map() {
        String($0)
    }

    //e.如果只有一个参数，还可以省略()
    array.map {
        String($0)
    }

    //f. autoClosure
    func autoClosureFunc(_ lhs: Int, _ rhs: Int, _ compare: @autoclosure (Int, Int)->Bool) -> Bool {
        return compare(lhs, rhs)
    }

    let ret = autoClosureFunc(1, 2, 1 > 2)

归并排序

//使用 Swift 来实现一个归并排序
//归并排序会不断的把无序数组二分，直到只有一个，变成有序，然后借助一个合并函数来合并两个有序的数组

extension Array where Element: Comparable {
    //这里记住endIndex 是超过count的位置，代表不可达的位置
    mutating func mergeSort(_ begin: Index, _ end: Index) {
        guard end - begin > 1 else {
            return
        }

        var tmp: [Element] = []
        tmp.reserveCapacity(count)

        //合并两个有序数组的方法
        func merge(_ start: Index, _ mid: Index, _ end: Index) {
            var x = begin
            var y = mid

            while x != mid, y != end {
                if (self[x] < self[y]) {
                    tmp.append(self[x])
                    x += 1
                } else {
                    tmp.append(self[y])
                    y += 1
                }
            }
            //一定存在一个数组被取空，所以需要把剩余的合并进去
            tmp.append(contentsOf: self[x..<mid])
            tmp.append(contentsOf: self[y..<end])

            replaceSubrange(begin..<end, with: tmp)
        }

        let middle = (begin + end) / 2
        mergeSort(begin, middle)
        mergeSort(middle, end)
        merge(begin, middle, end)

    }
}

比较

//基于运行时的NSSortDescriptor 比较需要提供的是keyPath 与 Selector，如果出现不匹配的情况
//很容易出现运行时异常
struct SortedStruct: Comparable {
    var name: String
    var type: Int

    public static func <(lhs: SortedStruct, rhs: SortedStruct) -> Bool {
        return lhs.name < rhs.name
    }

    public static func ==(lhs: SortedStruct, rhs: SortedStruct) -> Bool {
        return lhs.name == rhs.name
    }
}

    var structArray: [SortedStruct] = [
            SortedStruct(name: "Fpp", type: 11),
            SortedStruct(name: "cc", type: 2)
    ]

    structArray.sort(by: >)

重载操作符

//重载操作符号 infix 居中， prefix 前置，postfix 后置
//LogicalConjunctionPrecedence 逻辑优先级
infix operator |>:LogicalConjunctionPrecedence
func |><T: Comparable>(lhs: T, rhs: T) -> Bool {
    return lhs > rhs
}
print(1|>2)

设置只能被Class实现的协议

protocol onlyClassProtocol: class {

}

@escapting

//@escapting 会超出当前函数的作用域，最后一个return后依然会被执行
func escaptingClosure(first: Int, escapting: @escapting (Int)->Void) {
    escapting(first)
}