分享一下Swift中数组的几个好用的方法，他们都是通过闭包来调用，使用起来很方便、高效：

1、map

对数组的操作，经常会需要遍历数组中的每个元素，我们有常见的做法：

for 的快速遍历：

let array = ["a","b","c","d","e","f"]

for item in array {

print(item)

}

for 的这种OC经典写法，在Swift中已经弃用：

for (var index = 0; index < array.count; index ++) {

print(array[index])

}

如果想在遍历的过程得到每个元素的索引下标，可以这样：

for index in 0...array.count-1 {

print(array[index])

}

还有一个方法：

for (index,value) in array.enumerated() {

print(index,value)

}

再调用 reversed 方法还可以反向遍历：

for (index,value) in array.enumerated().reversed() {

print(index,value)

}

下面要介绍的是map方法：

public func map(_ transform: (Element) throws -> T) rethrows -> [T]

map函数以一个闭包函数作为参数，返回一个新的数组，编译器会自动根据调用它的数组类型自动推断出返回数组的类型：

let newArray = array.map { (str) -> String in

return str+"1"

}

print("newArray: \(newArray)")

打印结果：

2、flatMap

flatMap方法是在map方法的基础上增加了新的功能：

a、空值过滤

调用flatMap生成的新数组过滤掉了nil值的元素，得到的新数组里面全部都是非nil得元素：

let array = ["a", "b", "c", nil]

let newArray = array.flatMap { $0 }

print("newArray: \(newArray)"

打印结果：

let newArray = array.flatMap { $0 }  这种是最简洁的写法，$0 是参数名的缩写，$0、$1、$2...依次代表闭包中的第1、2、3...个参数，我们可以依次还原它的最原始的写法：

b、强解包

flatMap
会自动帮我们做了解包的工作，不用我们额外去解包元素，以map方法作对比：

let array: [String?] = ["abc", "de", "fgh"]

let newArray = array.map { $0 }

print("newArray: \(newArray)")

打印结果：

let array: [String?] = ["abc", "de", "fgh"]

let newArray = array.flatMap { $0 }

print("newArray: \(newArray)")

打印结果：

c、数组压平

所谓压平，其实就是把一个二维数组里面的元素（数组）展开成一维数组：

let array = [["abc", "de"], ["fgh","ij"]]

let newArray = array.flatMap { $0 }

print("newArray: \(newArray)")

打印结果：

3、filter

一般在我们遍历数组时可能都是为了过滤一些想要的数据，例如：我们想在array里面找到包含"a"字符的字符串，常规的做法：

let array = ["adl","er","kg","asl","fe","341a","vfl","ac"]

var newArray: [String] = []

for item in array {

if item.contains("a") {

newArray.append(item)

}

}

print("newArray: \(newArray)")

filter的用法就更加方便简洁：

public func filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]

filter从字面上理解就是过滤，调用这个方法时，传入一个闭包函数作为参数，给定判断条件，可以得到一个新的符合条件的数组：

let newArray = array.filter { (str) -> Bool in

return str.contains("a")

}

print("newArray : \(newArray)")

打印结果：

4、first

这个方法类似filter，不同的是这个方法遍历时匹配到一个满足条件的元素就不会继续遍历下去，跳出循环，也就是匹配到第一个就结束，如果确定数组中只有一个满足条件的元素就可以用这个匹配方法，不用进行其他多余的遍历：

public func first(where predicate: (Element) throws -> Bool) rethrows -> Element?

例如：

let array = ["adl","er","kg","asl","fe","341a","vfl","ac"]

let item = array.first { (str) -> Bool in

let index = array.index(of: str)

print("index : \(index!)")

return str.contains("r")

}

print("filter item: \(item!)")

打印结果：

5、reduce

这个方法可以用于计算数组里面每个元素相加后的值：

public func reduce(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result

let array = [1,4,7]

let initialResult = 0

let result = array.reduce(initialResult) { (tempResult, element) -> Int in

return tempResult + element

}

print("result: \(result)")

打印结果：

以上是个人见解，如有不足或错误，欢迎指教，谢谢！😊