對于喜歡直接看代碼的小伙伴們來說，可以直接跳過 一、二、三，直接看第四步，就找到你喜歡的code了。
一、學習背景
使用swift語言也有一年了，說來慚愧，遇到問題百度的時候多，大部分都是問題解決了，然后也就遺忘了，并沒有深究過，下次遇到要么翻看之前的代碼，要么繼續(xù)百度，不得不說自己很頹廢了。
今天遇到一個問題，找到答案后，發(fā)現(xiàn)swift中有好幾個方法，很常用，但是卻用的不熟練。這次學習以練習為主，目的就是提高對這幾個方法的熟練使用程度。
二、map方法初見
方法的作用
map: 可以對數(shù)組中的每一個元素做一次處理, 返回一個泛型的數(shù)組。方法的官方聲明和注釋(
不想看的可略過)
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]
三、此方法為何看起來不那么親切？
這個函數(shù)之所以感覺陌生，是因為多了一些swift的特性，比如這個函數(shù)中使用了“閉包”, 使用了“泛型”
閉包：transform: (Element) throws -> T
泛型：T
閉包的返回類型以及函數(shù)的返回類型都是泛型，也就是沒有固定類型，只需要根據(jù)使用的時候決定的類型。
這個概念有點兒抽象，類似C++的模板函數(shù)。多練習，多使用會慢慢明白，并體會它的好處的。
四、 使用和詳解
- 案例一
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類型的數(shù)組。
此時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)]
詳解：
這是上面閉包的省略寫法，這里省略了閉包的參數(shù)和返回類型，真正的返回類型是根據(jù)return語句推導出來的，返回Int類型的值，這里T也就是Int類型。
為什么結果是可選類型？
因為原來數(shù)組中的元素是可選類型的，我們沒有強制解包，所以返回的元素的值也是可選類型的。
$0是怎么回事？
這里的$0就是原數(shù)組的每一個元素，相當于上面的obj，類型是Any? 。省略了閉包參數(shù)，我們就使用$0來代替。如果參數(shù)有多個，我們依次使用$1,$2,$3......來代替。
關于閉包簡化的寫法部分可以自行學習參考 “閉包”這部分內(nèi)容，這里不做詳述。
閉包知識點：http://m.itdecent.cn/p/12ab2cfbc0bb
*/
- 案例二
操作String類型的數(shù)組：
let arrayString = ["Ann", "Bob", "Tom", "Lily", "HanMeiMei", "Jerry"]
print("-----------------案例二----------------------")
let arrayString = ["Ann", "Bob", "Tom", "Lily", "HanMeiMei", "Jerry"]
// 計算每個元素的個數(shù)，生成個數(shù)數(shù)組
let arrayCount = arrayString.map { (str) -> Int in
return str.count
}
print("arrayCount: \(arrayCount)")
// arrayCount: [3, 3, 3, 4, 9, 5]
/*
詳解：
這里的閉包是 (str) -> Int， 函數(shù)返回值也是 Int 。
此時的map函數(shù)相當于
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具有類型推導功能，根據(jù)返回語句 $0.count 就可以知道 T = Int， 那么我們也就知道函數(shù)的返回值是 [Int]， 閉包的返回值是 Int 。
我們返回一個字典，字典的key是原數(shù)組的元素，value是元素的長度。
let arrayDict = arrayString.map { [$0: $0.count] }
print("arrayDict: \(arrayDict)")
// arrayDict: [["Ann": 3], ["Bob": 3], ["Tom": 3], ["Lily": 4], ["HanMeiMei": 9], ["Jerry": 5]]
我們把原數(shù)組中的元素全部變成小寫
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", ""]
總結：
這個方法能夠?qū)?shù)組的每個元素進行操作，返回處理以后的元素，需要注意的是，這個方法的閉包具有返回值，也就是不滿足條件的時候，也要返回一個元素。
歡迎留言討論。
