wuleijun / Swift-Map-Filter-Reduce

A demo contains some explaining codes for map,flatMap,filter,reduce.

Geek Repo:Geek Repo

Github PK Tool:Github PK Tool

此文初始发布在我的简书

Swift是支持一门函数式编程的语言,拥有MapFlatMap,Filter,Reduce针对集合类型的操作。在使用Objective-C开发时,如果你没接触过函数式编程,那你可能没听说过这些名词,希望此篇文章可以帮助你了解Swift中的MapFlatMap,Filter,Reduce。 #Map 首先我们来看一下mapSwift中的的定义,我们看到它可以用在 Optionals 和 SequenceType 上(如:数组、词典等)。

public enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible {
    /// If `self == nil`, returns `nil`.  Otherwise, returns `f(self!)`.
    @warn_unused_result
    public func map<U>(@noescape f: (Wrapped) throws -> U) rethrows -> U?
}

extension CollectionType {
    /// Returns an `Array` containing the results of mapping `transform`
    /// over `self`.
    ///
    /// - Complexity: O(N).
    @warn_unused_result
    public func map<T>(@noescape transform: (Self.Generator.Element) throws -> T) rethrows -> [T]
}

@warn_unused_result:表示如果没有检查或者使用该方法的返回值,编译器就会报警告。 @noescape:表示transform这个闭包是非逃逸闭包,它只能在当前函数map中执行,不能脱离当前函数执行。这使得编译器可以明确的知道运行时的上下文环境(因此,在非逃逸闭包中可以不用写self),进而进行一些优化。 #####对 Optionals进行map操作 简要的说就是,如果这个可选值有值,那就解包,调用这个函数,之后返回一个可选值,需要注意的是,返回的可选值类型可以与原可选值类型不一致:

///原来类型: Int?,返回值类型:String?
var value:Int? = 1
var result = value.map { String("result = \($0)") }
/// "Optional("result = 1")"
print(result)
var value:Int? = nil
var result = value.map { String("result = \($0)") }
/// "nil"
print(result)

#####对SequenceType进行map操作 我们可以使用map方法遍历数组中的所有元素,并对这些元素一一进行一样的操作(函数方法)。map方法返回完成操作后的数组。 我们可以用For-in完成类似的操作:

var values = [1,3,5,7]
var results = [Int]()
for var value in values {
    value *= 2
    results.append(value)
}
//"[2, 6, 10, 14]"
print(results)

这看起来有点麻烦,我们得先定义一个变量var results然后将values里面的元素遍历,进行我们的操作以后,将其添加进results,我们比较下使用map又会怎么样:

let results = values.map ({ (element) -> Int in
    return element * 2
})
//"[2, 6, 10, 14]"

我们向map传入了一个闭包,对数组中的所有元素都 乘以2,将返回的新的数组赋值为results,是不是精简了许多?还能更精简! ####精简写法

let results = values.map { $0 * 2 }
//"[2, 6, 10, 14]"

what the fuck...沉住气,让我们一步步来解析怎么就精简成这样了,保证让你神清气爽。翻开The Swift Programming Language中对于闭包的定义你就能找到线索。 #####第一步: 由于闭包的函数体很短,所以我们将其改写成一行:

let results = values.map ({ (element) -> Int in return element * 2 })
//"[2, 6, 10, 14]"

#####第二步: 由于我们的闭包是作为map的参数传入的,系统可以推断出其参数与返回值,因为其参数必须是(Element) -> Int类型的函数。因此,返回值类型,->及围绕在参数周围的括号都可以被忽略:

let results = values.map ({ element  in return element * 2 })
//"[2, 6, 10, 14]"

#####第三步: 单行表达式闭包可以通过省略return来隐式返回闭包的结果:

let results = values.map ({ element  in element * 2 })
//"[2, 6, 10, 14]"

由于闭包函数体只含有element * 2这单一的表达式,该表达式返回Int类型,与我们例子中map所需的闭包的返回值类型一致(其实是泛型),所以,可以省略return。 #####第四步: 参数名称缩写(Shorthand Argument Names),由于Swift自动为内联闭包提供了参数缩写功能,你可以直接使用$0,$1,$2...依次获取闭包的第1,2,3...个参数。 如果您在闭包表达式中使用参数名称缩写,您可以在闭包参数列表中省略对其的定义,并且对应参数名称缩写的类型会通过函数类型进行推断。in关键字也同样可以被省略:

let results = values.map ({ $0 * 2 })
//"[2, 6, 10, 14]"

例子中的$0即代表闭包中的第一个参数。 #####最后一步: 尾随闭包,由于我们的闭包是作为最后一个参数传递给map函数的,所以我们可以将闭包表达式尾随:

let results = values.map (){ $0 * 2 }
//"[2, 6, 10, 14]"

如果函数只需要闭包表达式一个参数,当您使用尾随闭包时,您甚至可以把()省略掉:

let results = values.map { $0 * 2 }
//"[2, 6, 10, 14]"

如果还有不明白的,可以多翻阅翻阅The Swift Programming Language

#FlatMap 与map一样,它可以用在 Optionals和 SequenceType 上(如:数组、词典等)。我们先来看看针对Optional的定义: #####对 Optionals进行flatMap操作

public enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible {
    /// Returns `nil` if `self` is `nil`, `f(self!)` otherwise.
    @warn_unused_result
    public func flatMap<U>(@noescape f: (Wrapped) throws -> U?) rethrows -> U?
}

就闭包而言,这里有一个明显的不同,这次flatMap期望一个 (Wrapped) -> U?)闭包。对于可选值, flatMap 对于输入一个可选值时应用闭包返回一个可选值,之后这个结果会被压平,也就是返回一个解包后的结果。本质上,相比 map,flatMap也就是在可选值层做了一个解包。

var value:String? = "1"
var result = value.map { Int($0)}
/// "Optional(Optional(1))"
print(result)
var value:String? = "1"
var result = value.flatMap { Int($0)}
/// ""Optional(1)"
print(result)

使用flatMap就可以在链式调用时,不用做额外的解包工作:

var value:String? = "1"
var result = value.flatMap { Int($0)}.map { $0 * 2 }
/// ""Optional(2)"
print(result)

#####对SequenceType进行flatMap操作 我们先来看看Swift中的定义

extension SequenceType {
    /// 返回一个将变换结果连接起来的数组
    /// `transform` over `self`.
    ///     s.flatMap(transform)
    /// is equivalent to
    ///     Array(s.map(transform).flatten())
    @warn_unused_result
    public func flatMap<S : SequenceType>(transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
}

extension SequenceType {
    /// 返回一个包含非空值的映射变换结果
    @warn_unused_result
    public func flatMap<T>(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]
}

通过这两个描述,就提现了flatMapSequenceType的两个作用: #####一:压平

var values = [[1,3,5,7],[9]]
let flattenResult = values.flatMap{ $0 }
/// [1, 3, 5, 7, 9]

#####二:空值过滤

var values:[Int?] = [1,3,5,7,9,nil]
let flattenResult = values.flatMap{ $0 }
/// [1, 3, 5, 7, 9]

#Filter 同样,我先来看看Swift中的定义:

extension SequenceType {
    /// 返回包含原数组中符合条件的元素的数组
    /// Returns an `Array` containing the elements of `self`,
    /// in order, that satisfy the predicate `includeElement`.
    @warn_unused_result
    public func filter(@noescape includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
}

filter函数接受一个(Element) -> Bool)的闭包,来判断原数组中的元素是否符合条件,这个方法用来过滤数组中的一些元素再好不过了:

var values = [1,3,5,7,9]
let flattenResults = values.filter{ $0 % 3 == 0}
//[3, 9]

我们向flatMap传入了一个闭包,筛选出了能被3整除的数据。

#Reduce 我们先来看下Swift中的定义:

extension SequenceType {
    /// Returns the result of repeatedly calling `combine` with an
    /// accumulated value initialized to `initial` and each element of
    /// `self`, in turn, i.e. return
    /// `combine(combine(...combine(combine(initial, self[0]),
    /// self[1]),...self[count-2]), self[count-1])`.
    @warn_unused_result
    public func reduce<T>(initial: T, @noescape combine: (T, Self.Generator.Element) throws -> T) rethrows -> T
}

给定一个初始化的combine结果,假设为result,从数组的第一个元素开始,不断地调用combine闭包,参数为:(result,数组中的元素),返回的结果值继续调用combine函数,直至元素最后一个元素,返回最终的result值。来看下面的代码(为了更方便你理解这个过程,代码就不简写了):

var values = [1,3,5]
let initialResult = 0
var reduceResult = values.reduce(initialResult, combine: { (tempResult, element) -> Int in
    return tempResult + element
})
print(reduceResult)
//9

我们存在一个数组[1,3,5],给定了一个初始化的结果 initialResult = 0,向reduce函数传了 (tempResult, element) -> Int的闭包,tempResut便是每次闭包返回的结果值,并且其初始值为我们之前设置的initialResult0element即为我们数组中的元素(可能为1,3,5)。reduce会一直调用combine闭包,直至数组最后一个元素。下面的代码更形象地描述了整个过程,这其实跟reduce所做的操作是等价的:

func combine(tempResult: Int, element: Int) -> Int  {
    return tempResult + element
}
reduceResult = combine(combine(combine(initialResult, element: 1), element: 3), element: 5)
print(reduceResult)
//9

以上所用的一些示例代码可以在我的Github中找到,如果您有什么建议可以在评论区留言。

About

A demo contains some explaining codes for map,flatMap,filter,reduce.


Languages

Language:Swift 100.0%