一、Array常用的内置函数
- map
- flatMap
- compactMap
- reduce
1、map
-
map：
- 是用来映射其他值。
- 要求接收的元素必须是数组中的元素。
- 遍历数组中的元素，传入到后面的闭包里，闭包返回值是新组成的数组。
映射为新的数组
let array = [1,2,3,4,5,6]
var arr = array.map { i in
return i * 2
}
// 简写
var arr2 = array.map { $0 * 2 }
//[2, 4, 6, 8, 10, 12]
映射为String
var arr = array.map { index in
return "S\(index)"
}
print("arr: ",arr) //["S1", "S2", "S3", "S4", "S5", "S6"]
映射为Dictionary
var dict = array.map { index in
return ["key\(index)": index]
}
print(dict)
-
map的lazy的优化
- 如果没有lazy，在begin之前arr中的元素已经映射完，但有时候这样比较浪费和耗时。
- 如果有lazy，用到哪个元素才映射哪个元素。
let arr = [1, 2, 3]
let result = arr.lazy.map { //有lazy
(i: Int) -> Int in
print("mapping \(i)")
return i * 2
}
print("begin-----")
print("mapped", result[0])
print("mapped", result[1])
print("mapped", result[2])
print("end----")
2、flatMap（紧贴、平坦、展开）
-
flatMap与map的区别
- flatMap：会将数组中的元素展开放到一个新数组中，返回新数组。
- map：返回值都会放到新组成的数组中，如果是数组不会摊开。
let arr2 = array.flatMap { index in
Array.init(repeating: index, count: index)
}
print(arr2)
//[1, 2, 2, 3, 3, 3]
let array = [1,2,3]
let arr = array.map { index in
Array.init(repeating: index, count: index)
}
print(arr)
//[[1], [2, 2], [3, 3, 3]]
3、compactMap（压缩、结实）
- compactMap：会将新数组中的元素解包，如果是nil就清除这个元素，最后返回新数组。
var array = ["123", "test", "jack", "-30"]
var arr2 = array.compactMap { Int($0) } //压缩
print(arr2)
// [123, -30]
- map：类型转换可能会失败，转换成功的元素是可选类型，转换失败则是nil。
var array = ["123", "test", "jack", "-30"]
var arr3 = array.map { Int($0) }
print(arr3)
// [Optional(123), nil, nil, Optional(-30)]
4、filter
- 用于过滤，在闭包中自己决定数组中的元素为true或者false
- 如果为true，返回的新数组中就会放着该元素
- 如果为false，该元素就被过滤掉。
//过滤奇数，返回偶数
var arr = array.filter { index in
print(index, index % 2 == 0)
return (index % 2 == 0)
}
print(arr) //[2, 4, 6]
5、reduce
-
reduce：遍历数组中所有元素，进行有关联的操作
- 例如下一次的遍历需要用到上一次的结果
- 每次遍历都有关联
- initialResult：初始值
- result：是上一次return的结果
- item：是数组中的元素
let array = [1,2,3,4,5]
let arr = array.reduce(0) { result, item in
return result + item
}
print(arr) // 15
- 简写
let arr1 = array.reduce(0) { $0 + $1 }
var arr2 = array.reduce(0, +)
扩展
- 使用reduce实现map的功能
var arr = [1, 2, 3, 4]
//[2, 4, 6, 8]
print(arr.map { $0 * 2 })
print(arr.reduce([]) { $0 + [$1 * 2] })
//和上面map一样
- 使用reduce实现filter的功能
print(arr.filter { $0 % 2 == 0 })
print(arr.reduce([]) { $1 % 2 == 0 ? $0 + [$1] : $0 })
//[2, 4]
//和上面filter一样
可选类型的map和flatMap
可选类型也有map和flatMap，可选类型的map和flatMap就是将.map前⾯的参数解包(就是$0)，解包成功后的值传给后⾯的函数，解包失败直接返回nil。
var num1: Int? = 10
var num2 = num1.map { $0 * 2 }
// Optional(20)
var num3: Int? = nil
var num4 = num3.map { $0 * 2 }
// nil
区别
- map：不管返回什么，都会进行再次包装。
- flatMap：发现返回的就是可选类型，不会在进行包装。
var num1: Int? = 10
// Optional(Optional(20))
var num2 = num1.map { Optional.some($0 * 2) }
// Optional(20)
var num3 = num1.flatMap { Optional.some($0 * 2) }
num2、num3是等价的
var num1: Int? = 10
var num2 = (num1 != nil) ? (num1! + 10) : nil
var num3 = num1.map { $0 + 10 }
例1
1.日期格式化
var fmt = DateFormatter()
fmt.dateFormat = "yyyy-MM-dd"
var str: String? = "2011-09-10"
- 常规做法
var date = str != nil ? fmt.date(from: str!) : nil
- 使用可选绑定
if let s = str {
fmt.date(from: s)
}
- 使用map
- 发现date是Date??类型
var date = str.map { string in
fmt.date(from: string)
}
- 使用flatMap
- 如果返回的是可选类型就不会再包装一层
var date = str.flatMap{fmt.date(from: $0)}
- 下面的写法更精简
- 闭包表达式本质就是函数，str如果有值就会解包，解包之后的值就是
$0，在调用fmt.date(from: $0)。 -
fmt.date函数刚好是接收字符串作为参数，会将str.flatMap解包之后的字符串直接传给fmt.date这个参数
- 闭包表达式本质就是函数，str如果有值就会解包，解包之后的值就是
var date = str.flatMap(fmt.date)
例2
- 常规写法
var score: Int? = 98
var str1 = score != nil ? "socre is \(score!)" : "No score"
// score is 98
- 使用map
- 如果不为nil就将$0包装成可选字符串
- 如果为nil就返回"No score"
var str2 = score.map { "score is \($0)" } ?? "No score"
// score is 98
例3
struct Person {
var name: String
var age: Int
}
var items = [
Person(name: "jack", age: 20),
Person(name: "rose", age: 21),
Person(name: "kate", age: 22)
]
- 常规写法
func getPerson1(_ name: String) -> Person? {
let index = items.firstIndex { $0.name == name }
return index != nil ? items[index!] : nil
}
- 使用map
- 索引如果有值就会调⽤.map，
- 索引没值就直接返回nil
func getPerson2(_ name: String) -> Person? {
//第一个$0代表items中的元素，第二个$0代表index
return items.firstIndex { $0.name == name }.map { items[$0] }
}
例4
struct Person {
var name: String
var age: Int
init?(_ json: [String : Any]) {
guard let name = json["name"] as? String, let age = json["age"] as? Int
else {
return nil
}
self.name = name
self.age = age
}
}
var json: Dictionary? = ["name" : "Jack", "age" : 10]
- 常规写法
var p1 = json != nil ? Person(json!) : nil
- 使用map
var p2 = json.flatMap(Person.init)
