对于喜欢直接看代码的小伙伴们来说，可以直接跳过 一、二、三，直接看第四步，就找到你喜欢的code了。
一、学习背景
使用swift语言也有一年了，说来惭愧，遇到问题百度的时候多，大部分都是问题解决了，然后也就遗忘了，并没有深究过，下次遇到要么翻看之前的代码，要么继续百度，不得不说自己很颓废了。
今天遇到一个问题，找到答案后，发现swift中有好几个方法，很常用，但是却用的不熟练。这次学习以练习为主，目的就是提高对这几个方法的熟练使用程度。
二、map方法初见
方法的作用
map: 可以对数组中的每一个元素做一次处理, 返回一个泛型的数组。方法的官方声明和注释(
不想看的可略过)
Returns an array containing the results of mapping the given closure over the sequence's elements. In this example, 'map' is used first to convert the names in the array to lowercase strings and then to count their characters.
/// let cast = ["Vivien", "Marlon", "Kim", "Karl"]
/// let lowercaseNames = cast.map {0.count }
/// // 'letterCounts' == [6, 6, 3, 4]
Parameter transform: A mapping closure. 'transform' accepts an element of this sequence as its parameter and returns a transformed value of the same or of a different type.
/// - Returns: An array containing the transformed elements of this sequence.
public func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
三、此方法为何看起来不那么亲切？
这个函数之所以感觉陌生，是因为多了一些swift的特性，比如这个函数中使用了“闭包”, 使用了“泛型”
闭包：transform: (Element) throws -> T
泛型：T
闭包的返回类型以及函数的返回类型都是泛型，也就是没有固定类型，只需要根据使用的时候决定的类型。
这个概念有点儿抽象，类似C++的模板函数。多练习，多使用会慢慢明白，并体会它的好处的。
四、 使用和详解
- 案例一
let arrayAny: [Any?] = [1, 2, 3, 4, 5, nil, "a", 8, "9"]
print(arrayAny)
let arrInt = arrayAny.map { (obj) -> Int in
if obj is Int {
return obj as! Int
} else {
return 0
}
}
print("arrInt: \(arrInt)")
// arrInt: [1, 2, 3, 4, 5, 0, 0, 8, 0]
详解：
这里的闭包是(obj) -> Int， 泛型T目前是Int类型，我们会获得一个Int类型的数组。
此时map方法就相当于：
public func map(_ transform: (Any?) throws -> Int) rethrows -> [Int]
返回的值为什么不是可选的呢？
因为我们进行了强制解包 obj as! Int 。
闭包简化写法
let arrInt2 = arrayAny.map {
return ($0 is Int) ? $0 : 0
}
print("arrInt2: \(arrInt2)")
// arrInt2: [Optional(1), Optional(2), Optional(3), Optional(4), Optional(5), Optional(0), Optional(0), Optional(8), Optional(0)]
详解：
这是上面闭包的省略写法，这里省略了闭包的参数和返回类型，真正的返回类型是根据return语句推导出来的，返回Int类型的值，这里T也就是Int类型。
为什么结果是可选类型？
因为原来数组中的元素是可选类型的，我们没有强制解包，所以返回的元素的值也是可选类型的。
$0是怎么回事？
这里的$0就是原数组的每一个元素，相当于上面的obj，类型是Any? 。省略了闭包参数，我们就使用$0来代替。如果参数有多个，我们依次使用$1,$2,$3......来代替。
关于闭包简化的写法部分可以自行学习参考 “闭包”这部分内容，这里不做详述。
闭包知识点：https://www.jianshu.com/p/12ab2cfbc0bb
*/
- 案例二
操作String类型的数组：
let arrayString = ["Ann", "Bob", "Tom", "Lily", "HanMeiMei", "Jerry"]
print("-----------------案例二----------------------")
let arrayString = ["Ann", "Bob", "Tom", "Lily", "HanMeiMei", "Jerry"]
// 计算每个元素的个数，生成个数数组
let arrayCount = arrayString.map { (str) -> Int in
return str.count
}
print("arrayCount: \(arrayCount)")
// arrayCount: [3, 3, 3, 4, 9, 5]
/*
详解：
这里的闭包是 (str) -> Int， 函数返回值也是 Int 。
此时的map函数相当于
public func map(_ transform: (String) throws -> Int) rethrows -> [Int]
*/
闭包简化写法，省略变量和返回值
let arrayCount2 = arrayString.map { return $0.count }
print("arrayCount2: \(arrayCount2)")
//arrayCount2: [3, 3, 3, 4, 9, 5]
闭包再次简化，省略return
let arrayCount3 = arrayString.map { $0.count }
print("arrayCount3: \(arrayCount3)")
//arrayCount3: [3, 3, 3, 4, 9, 5]
详解：
这两个都是简化写法，也是常用的写法，因为这样看起来很简练，也很清晰， 适用于只有一条语句的情况, 如果是多条语句，不建议写在一行。
泛型T是如何确定类型的？
我们知道swift具有类型推导功能，根据返回语句 $0.count 就可以知道 T = Int， 那么我们也就知道函数的返回值是 [Int]， 闭包的返回值是 Int 。
我们返回一个字典，字典的key是原数组的元素，value是元素的长度。
let arrayDict = arrayString.map { [$0: $0.count] }
print("arrayDict: \(arrayDict)")
// arrayDict: [["Ann": 3], ["Bob": 3], ["Tom": 3], ["Lily": 4], ["HanMeiMei": 9], ["Jerry": 5]]
我们把原数组中的元素全部变成小写
let arrayLow = arrayString.map { $0.lowercased() }
print("arrayLow: \(arrayLow)")
// arrayLow: ["ann", "bob", "tom", "lily", "hanmeimei", "jerry"]
返回包含i的元素组合
let arrayI = arrayString.map { $0.contains("i") ? $0 : "" }
print("arrayI: \(arrayI)")
// arrayI: ["", "", "", "Lily", "HanMeiMei", ""]
总结：
这个方法能够对数组的每个元素进行操作，返回处理以后的元素，需要注意的是，这个方法的闭包具有返回值，也就是不满足条件的时候，也要返回一个元素。
欢迎留言讨论。
