函数式Swift的知识点

@escaping 逃逸闭包

“当需要在函数返回之后使用其参数（如：region）时，该参数需要被标记为 @escaping。即使忘记标记，编译器也将会提醒我们。如果你想了解更详细的信息，请参阅 Apple 的 The Swift Programming Language 一书中《逃逸闭包》的部分。”

柯里化

形如 blur(radius: radius)(image)

参数的分别传入计算函数的, 这样的形式更易于函数的组合.

Map函数的实现

extension Array {
    func map<T>(_ transform: (Element) -> T) -> [T] {
        var result: [T] = []
        for x in self {
            result.append(transform(x))
        }
        return result
    }
}

• 使用

func genericCompute<T>(array: [Int], transform: (Int) -> T) -> [T] {
    return array.map(transform)
}

Filter函数的实现

extension Array {
    func filter(_ includeElement: (Element) -> Bool) -> [Element] {
        var result: [Element] = []
        for x in self where includeElement(x) {
            result.append(x)
        }
        return result
    }
}

• 使用

func getSwiftFiles(in files: [String]) -> [String] {
    return files.filter { file in file.hasSuffix(".swift") }
}

Reduce函数实现

• 一般的Reduce行为

func prettyPrint(strings: [String]) -> String {
    var result: String = "Entries in the array xs:\n"
    for string in strings {
        result = " " + result + string + "\n"
    }
    return result
}

• 泛型实现

extension Array {
    func reduce<T>(_ initial: T, combine: (T, Element) -> T) -> T {
        var result = initial
        for x in self {
            result = combine(result, x)
        }
        return result
    }
}

• 使用Reduce 实现 Map 和 Filter

extension Array {
    func mapUsingReduce<T>(_ transform: (Element) -> T) -> [T] {
        return reduce([]) { result, x in
            return result + [transform(x)]
        }
    }
    func filterUsingReduce(_ includeElement: (Element) -> Bool) -> [Element] {
        return reduce([]) { result, x in
            return includeElement(x) ? result + [x] : result
        }
    }
}

实际运用 Map Filter和Reduce

struct City {
    let name: String
    let population: Int
}

我们可以定义一些示例城市：

let paris = City(name: "Paris", population: 2241)
let madrid = City(name: "Madrid", population: 3165)
let amsterdam = City(name: "Amsterdam", population: 827)
let berlin = City(name: "Berlin", population: 3562)
let cities = [paris, madrid, amsterdam, berlin]

假设我们现在想筛选出居民数量至少一百万的城市，并打印一份这些城市的名字及总人口数的列表。我们可以定义一个辅助函数来换算居民数量：

extension City {
    func scalingPopulation() -> City {
        return City(name: name, population: population * 1000)
    }
}

现在我们可以使用所有本章中见到的函数来编写下面的语句：

cities.filter { $0.population > 1000 }
    .map { $0.scalingPopulation() }
    .reduce("City: Population") { result, c in
        return result + "\n" + "\(c.name): \(c.population)"
}
/*
 City: Population
 Paris: 2241000
 Madrid: 3165000
 Berlin: 3562000
 */
 

泛型和Any类型

泛型: 具备编辑器的类型检查, 使用泛型更具有通用性

Any: 则可以避开Swift的类型系统

可选值

let cities = ["Paris": 2241, "Madrid": 3165, "Amsterdam": 827, "Berlin": 3562]

可选绑定

if let madridPopulation = cities["Madrid"] {
    print("The population of Madrid is \(madridPopulation * 1000)")
} else {
    print("Unknown city: Madrid")
}

?? 运算符

默认值使用闭包, 可以避免不必要的计算

这里是运用的重点: 闭包的使用!!!

infix operator ??
func ??<T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T {
    if let x = optional {
        return x
    } else {
        return try defaultValue()
    }
}

if 可选链

if let myState = order.person?.address?.state {
    print("This order will be shipped to \(myState)")
} else {
    print("Unknown person, address, or state.")
}

switch 的可选值

可以再case中使用 ? 解绑可选值

switch madridPopulation {
case 0?: print("Nobody in Madrid")
case (1..<1000)?: print("Less than a million in Madrid")
case let x?: print("\(x) people in Madrid")
case nil: print("We don't know about Madrid")
}

guard 的可选值

func populationDescription(for city: String) -> String? {
    guard let population = cities[city] else { return nil }
    return "The population of Madrid is \(population)"
}

可选映射 Optional.map

Optional 也提供了 map 函数, 可以对其解绑值进行处理

extension Optional {
    func map<U>(_ transform: (Wrapped) -> U) -> U? {
        guard let x = self else { return nil }
        return transform(x)
    }
}

func increment(optional: Int?) -> Int? {
    return optional.map { $0 + 1 }
}

flatMap帮助解绑

其区别是和 map 的参数闭包的返回值类型 仍然是 可选类型

extension Optional {
    func flatMap<U>(_ transform: (Wrapped) -> U?) -> U? {
        guard let x = self else { return nil }
        return transform(x)
    }
}


extension Array{    
    func myFlatMap<T>(_ transform: (Element) -> [T]) -> [T] {
        var tmp: [T] = []
        for value in self {
            tmp.append(contentsOf: transform(value));
        }
        return tmp; 
    }
}