Swift数组进阶函数

WHAT

• Map,Filter,Reduce是什么？

Swift的标准数组支持三个高阶函数：map,filter和reduce.是OC中没有实现的方法。

• map:map方法作用是把数组[T]通过闭包函数把每一个数组中的元素变成U类型的值，最后组成数组[U]。定义如下：
  func map(transform: (T) -> U) -> [U]

• filter就是筛选的功能，参数是一个用来判断是否筛除的筛选闭包，根据闭包函数返回的Bool值来过滤值。为True则加入到结果数组中。定义如下：
  func filter(includeElement: (T) -> Bool) -> [T]

• reduce的作用给定一个类型为U的初始值，把数组[T]中每一个元素传入到combine的闭包函数里面，通过计算得到最终类型为U的结果值。定义如下：
  func reduce(initial: U, combine: (U, T) -> U) -> U

WHY

• 为什么要使用Map,Filter,Reduce

  • 方便：代码量极少，节省时间
  • 简洁：符合Swift语言风格，当你使用map，filter，reduct的代码质量会更好。但也需要在合适的场景中使用它们，不要指望用它们来解决任何问题。没有放之四海而皆准的真理。
  • 效率：数据比较大的时候，高阶函数会比传统实现更快，因为它可以并行执行（如运行在多核上），除非真的需要更高定制版本的map，reduce和filter，否则可以一直使用它们以获得更快的执行速度。

HOW

• 怎么使用

Map

在OC中，对数组元素的操作是很不方便的一件事，遍历，操作，赋值给新数组，显得太繁琐。
在swift中，对数组的操作就简洁了很多。

map方法作用是把数组[T]通过闭包函数把每一个数组中的元素变成U类型的值，最后组成数组[U]
原型如下：
func map(transform: (T) -> U) -> [U]

在Functional Programming in Swift中，实现了map函数如下：

 

func map<T, U>(xs: [T], f: T -> U) -> [U]
{ 
    var result: [U] = []
    for x in xs 
    {
        result.append(f(x)) 
    }
    return result 
}

• 将示例数组，每个数字都加10，获得一个新的数组：

 

//map函数里面可以直接使用函数作为参数,这里采用函数的方式。
let numberArray = [1,2,3,4,5]

func fmap(a : Int) -> Int{
    return a + 10
}

var result = numberArray.map(fmap)

print(result)

 

//采用闭包的方式
var result = numberArray.map({($0) + 10})
print(result)

• map不只是可以用来做简单的数值运算，还可以处理一些其他复杂操作，如：在数字后拼接字符串，返回新的数组

用常规方式写：

 

for number in numberArray {
    stringsArray.append("\(number)只")
}
print(stringsArray)

使用map：

 

resultArray = numberArray.map({"\($0)只"})
print(resultArray)

如此简洁，尝试一下用OC实现的话。。。

FlatMap

flatMap 更加强大，可以传入N个处理方法，将处理后得到数据，组合到同一个数组中

 

resultArray = numberArray.flatMap({["\($0)个","\($0 )只"]})
print(resultArray)
//输出结果：

["1个", "1只", "2个", "2只", "3个", "3只", "4个", "4只", "5个", "5只"]

Filter

filter就是筛选的功能，参数是一个用来判断是否筛除的筛选闭包，根据闭包函数返回的Bool值来过滤值。为True则加入到结果数组中。定义如下：
func filter(includeElement: (T) -> Bool) -> [T]

• 找出数组中大于2的数

常规方式实现：

 

var filteredArray : [Int] = []
for number in numberArray {
    if number > 2 {
        filteredArray.append(number)
    }
}
print(filteredArray)

使用filter实现：

 

filteredArray = numberArray.filter({$0 > 2})
print(filteredArray)

一个数组
let numberArray = [1,2,3,4,5]

想要的结果
var resultArray = ["1只","2只","3只","4只","5只"]

常规方式实现：

 

for number in numberArray {
    stringsArray.append("\(number)只")  
}
print(stringsArray)

其实swift已经比OC简洁了。想更简洁一点？用map一句话就可以了（当然，加上输入语句的话，是2句）。

 

resultArray = numberArray.map({"\($0)只"})
print(resultArray)

reduce

reduce的作用给定一个类型为U的初始值，把数组[T]中每一个元素传入到combine的闭包函数里面，通过计算得到最终类型为U的结果值。

定义如下：
func reduce(initial: U, combine: (U, T) -> U) -> U

reduce的类似实现是：

 

func reduce<A, R>(arr: [A], _ initialValue: R, combine: (R, A) -> R) -> R
{
    var result = initialValue
    for i in arr
    {
        result = combine(result, i)
    }
    return result
}

let input = [1, 2, 3, 4]

var sum = reduce(input, 0){ x, y in x + y }

reduce函数还可以用来实现map函数和filter函数：

 

func mapUsingReduce<T, U>(xs: [T], f: T -> U) -> [U]
{
    return reduce(xs, []){ result, x in result + [f(x)] }
}


var result = mapUsingReduce(input){ x in x * 3 }
result1

func filterUsingReduce<T>(xs: [T], check: T -> Bool) -> [T]
{
    return reduce1(xs, [])
    { 
        result , x in return check(x) ? result + [x] : result 
    }
}

result = filterUsingReduce(exampleFiles)
            { 
                file in file.hasSuffix("swift") 
            }

• 计算数组中所有数字的和，积

常规方式实现：

 

var sum = 0
for number in numberArray {
    sum += number
}
print(sum)

var product = 1
for number in numberArray {
    product = product * number
}
print(product)

使用reduce实现：

 

sum = numberArray.reduce(0, combine: {$0 + $1})
print(sum)

也可以写为：

 

sum = numberArray.reduce(0, combine: +)