1. import UIKit
    3. //map
    4. //map会遍历数组的每个元素，遍历到一个元素，会调用一次闭包生成一个新的值，最终所有的值组成一个新的数组返回
    5. var arr = [1, 2, 3, 4, 5]
    6. var arr1 = arr.map { (i) -> Int in
    7.     return i * 2
    8. }
    9. print(arr1)
    10. //闭包表达式的简写
    11. var arr2 = arr.map { $0 * 2 }
    12. print(arr2)
    14. var ar = arr.map {
    15.     (i) -> String in
    16.     return "rulala_\(i)"
    17. }
    18. var arr3 = arr.map { "rulala_\($0)" }
    19. print(arr3)
    20. print(ar)
    23. //filter
    24. //filter会遍历数组的每个元素，如果元素满足一定的条件，就进行筛选过滤，最终筛选结果生成一个新的数组返回
    25. var arr4 = arr.filter {
    26.     (i) -> Bool in
    27.     return i % 2 == 0
    28. }
    29. var arr5 = arr.filter { $0 % 2 == 0 }
    30. print(arr4)
    31. print(arr5)
    34. //reduce
    35. //reduce 会遍历数组的每个元素，每遍历到一次，就调用一次闭包
    36. //例子里的result +element，就相当于数组每遍历一次，就将上一次的result跟元素element相加，
    37. //赋值给下一次的result，直到遍历结束：
    38. var arr6 = arr.reduce(0) { (result,element) -> Int in
    39.     return result + element
    40. }
    41. //reduce后的（0）就是指从0开始加：0+1+2+3+4+5
    42. var arr7 = arr.reduce(0) { $0 + $1 }
    43. print(arr7)
    44. print(arr6)
    45. //reduce后的（1）就是指从1开始乘：0*1*2*3*4*5
    46. var arr8 = arr.reduce(1) { $0 * $1 }
    47. print(arr8)
    50. //flatmap
    51. //map跟flatmap一样，最终都是生成一个新的数组返回，但是flatmap的区别是它-
    52. //-会将内部的元素都拆开统一生成一个大的数组返回。（flat有平铺的意思，可以这么理解）
    53. var arrr = [1, 2, 3]
    54. var arrr1 = arrr.map{ Array.init(repeating: $0, count: $0) }
    55. print(arrr1) // [[1], [2, 2], [3, 3, 3]]
    56. var arrr2 = arrr.flatMap { Array.init(repeating: $0, count: $0) }
    57. print(arrr2) // [1, 2, 2, 3, 3, 3]
    59. var arrrr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    60. var arrrr1 = arrrr.map{ $0 }
    61. arr1 // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    62. var arrrr2 = arrrr.flatMap{ $0 }
    63. arr2 // [1, 2, 3, 4, 5, 6, 7, 8, 9]
    66. //compactMap
    67. //当闭包中的返回结果是可选的时候，使用compactMap代替flatMap，同时在真正返回结果的时候，会自动过滤掉nil
    68. var aarr = [1, nil, 3, nil, 4, .none, Optional(6)]
    69. var aarr1 = aarr.compactMap { $0 }
    70. print(aarr1) // [1, 3, 4, 6]
    72. //下面的字符串数组中，分别采用map跟compactMap遍历数组。在map强转失败就是nil，
    73. //同时强转成功会处理成可选类型；而在compactMap中进行Int强转，不满足强转的元素会被当做nil过滤掉
    74. var  aaarr = ["123", "test", "jack", "-39"]
    75. var aaarr1 = aaarr.map { Int($0) }
    76. print(aaarr1) // [Optional(123), nil, nil, Optional(-39)]
    77. var aaarr2 = aaarr.compactMap { Int($0) }
    78. print(aaarr2) // [123, -39]