一直觉得自己写的不是技术，而是情怀，一个个的教程是自己这一路走来的痕迹。靠专业技能的成功是最具可复制性的，希望我的这条路能让你们少走弯路，希望我能帮你们抹去知识的蒙尘，希望我能帮你们理清知识的脉络，希望未来技术之巅上有你们也有我。
前言
高阶函数的使用为我们在开发过程中提供了很大的方便，使用起来也很方便，只要用熟了之后确实感觉很好用。
正题
forEach: 遍历
例如：用于修改模型中(符合条件)的值，例如：勾选购物车中的商品，选中的就打钩。
再举一个简单的例子：修改模型中的值
filter：筛选(常用)
struct Student {
let id: String
let name: String
let age: Int
}
let student1 = Student(id: "1", name: "student1", age: 11)
let student2 = Student(id: "2", name: "student2", age: 12)
let student3 = Student(id: "3", name: "student3", age: 13)
let students = [student1, student2, student3]
//filter
//这个函数就如同单词的意思：查找。将符合条件的元素查找出来放置在数组中返回。比如我们想查找年龄大于18岁的所有学生
let addDucts = students.filter { (student) -> Bool in
student.age >= 12
}
print("addDucts: \(addDucts)")
map：提取+转换(常用)
1.处理数组中的每个元素，并返回⼀个新的结果数组
2.它的作用一般在开发过程中用来转换当前模型,返回一个新的数组。
//map
struct Student {
let id: String
let name: String
let age: Int
}
let student1 = Student(id: "1", name: "student1", age: 11)
let student2 = Student(id: "2", name: "student2", age: 12)
let student3 = Student(id: "3", name: "student3", age: 13)
let students = [student1, student2, student3]
let intStudents = students.map { student in
Int(student.id)
}
print("intStudents \(intStudents)")//intStudents [Optional(1), Optional(2), Optional(3)]
map也可以用来处理元素
let num: Int? = 2
let result = num.map {
$0 * 2
}
print("result: \(result ?? 0)")//result: 4
compactMap：(处理数组) /kəmˈpækt /契约
compactMap是swift4.1的时候推出的Api，把可以说是用来替换flatMap，compactMap使用起来比flatMap更加灵活：
在Swift标准库中compactMap定义如下
public func compactMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
在Swift标准库中flatMap定义如下
public func flatMap(_ transform: (Element) throws -> String?) rethrows -> [String]
从定义可以看出，经过flatMap后一定变成字符串数组，而compactMap是任意类型的数组。从而compactMap使用更加灵活。
用来筛选出符合条件的数据，返回一个新的数组：
例子1：提取
struct Student {
let id: String
let name: String
let age: Int
}
let student1 = Student(id: "1", name: "student1", age: 11)
let student2 = Student(id: "2", name: "student2", age: 12)
let student3 = Student(id: "3", name: "student3", age: 13)
let students = [student1, student2, student3]
//compactMap 对于 Set 和 Array ，你可以使用 compactMap
let intIds = students.compactMap { (student) in
Int(student.id)
}
print("intIds: \(intIds)")//intIds: [1, 2, 3]
例子2：过滤
let nums = [0, nil, 1, nil, 2, nil, 3, nil, 4, nil, 5]
let result = nums.compactMap { (item) -> Int? in
return item
}
print(result) // [0, 1, 2, 3, 4, 5]
化简的写法：
let result = nums.compactMap { return $0 }
print(result) // [0, 1, 2, 3, 4, 5]
例子3：类型转换
let list = [1, 2, 3, 4, 5]
let newList = list.compactMap { (element) -> String? in
return "\(element)"
}
print(newList) // ["1", "2", "3", "4", "5"]
化简的写法：
let list = [1, 2, 3, 4, 5]
let newList = list.compactMap {return "\($0)"}
print(newList) // ["1", "2", "3", "4", "5"]
例子4：筛选数据
let list = [28, 54, 36, 62, 44, 33]
let result = list.compactMap { (element) -> Int? in
if element%4 == 0 {
return element
}
return nil
}
print(result) // [28, 36, 44]
compactMapValues (处理字典)
let dictionary = ["key1":10, "key2":20, "key3":nil]
let results = dictionary.compactMapValues{ $0 }
print("result: \(results)")//result: ["key2": 20, "key1": 10]
flatMap：映射扁平化(处理完一定返回字符串)
//flatMap
let scoreByName = ["henk":[0,5,8], "john":[2,5,8]]
let mapped = scoreByName.map { $0.value }
print("mapped: \(mapped)")//mapped: [[2, 5, 8], [0, 5, 8]]
let flatMapped = scoreByName.flatMap { $0.value}
print("flatMapped: \(flatMapped)")//flatMapped: [2, 5, 8, 0, 5, 8]
//map 会直接将元素放在数组中，而 flatMap 会将元素平铺在一个数组中。实际上，s.flatMap(transform) 等同于s.map(transform).joined()。
reduce (组合运算)
struct Student {
let id: String
let name: String
let age: Int
}
let student1 = Student(id: "1", name: "student1", age: 11)
let student2 = Student(id: "2", name: "student2", age: 12)
let student3 = Student(id: "3", name: "student3", age: 13)
let students = [student1, student2, student3]
//对于 reduce，我们的使用场景就是对数组中的元素进行组合运算，比如我们想计算所有学生的年龄加载一起是多少。
let totalAges = students.reduce(0) { result, student in
return result + student.age
}
print("totalAges: \(totalAges)")//totalAges: 36
高阶函数的组合使用
例子1：
//将 String 类型映射为 Int 类型，并查找id大于1002的所有学生
let adults = students.compactMap { (stu) in
Int(stu.id)
}.filter { (id) -> Bool in
id > 1
}
print(adults) //[2, 3]
例子2：
//计算年龄大于12的所有学生年龄总和
let totalAge = students.filter { (student) -> Bool in
student.age > 11
}.reduce(0) { (result, student) in
return result + student.age
}
print(totalAge) // 25
sort() 排序 /sɔːt/ 分类
从小到大排序 改变原来数组的顺序 不会产生新的数组
var list = [6,8,4,0,2,5,3,7,9,1];
list.sort()
print(list)
sorted() 排序
从小到大排序。 不改变原来数组的顺序。 会产生新的数组
var list = [6,8,4,0,2,5,3,7,9,1];
let arr = list.sorted()
print(arr)
sort(by: ) 排序
根据指定的法则 排序。 改变原来数组的顺序。 不会产生新的数组
var list = [6,8,4,0,2,5,3,7,9,1];
//根据指定的法则 排序。 改变原来数组的顺序。 不会产生新的数组
list.sort { num_0, num_1 in
return num_0 > num_1 ? true : false
}
print(list)
sorted(by: ) 排序
var list = [6,8,4,0,2,5,3,7,9,1];
let arr = list.sorted { num_0, num_1 in
return num_0 > num_1 ? true : false
}
print(arr)
shuffled 打乱数组
var list = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
list.shuffled()
print(list)
joined 数组转换成字符串拼接在一起。/dʒɔɪnd/ 已加入
let list = ["1","2","3"];
let title = list.joined(separator: " * ")
print("\(title)")
contains 是否包含. /kənˈteɪnz/ 包含
let arr = [1,2,3,4,5]
print("是否包含：\(arr.contains(1))")
prefix() 截取前面
let arr = [1,2,3,4,5]
print("截取前面：\(arr.prefix(2))")//不包含截取的位置
prefix(upTo: ) 截取指定值前面
let arr = [1,2,3,4,5]
print("截取指定值前面：\(arr.prefix(upTo: 3))")//包含截取的位置
suffix() 截取后面面
let arr = [1,2,3,4,5]
print("截取后面面：\(arr.suffix(2))")//不包含截取的位置
suffix(from: ) 截取指定值后面
let arr = [1,2,3,4,5]
print("截取指定值后面：\(arr.suffix(from: 1))")//不包含截取的位置
dropFirst 返回的是除首元素之外的片段
let array = [1,2,3,4]
print(array.dropFirst())//输出[2,3,4]
print(array.dropFirst(2))//输出[3,4]
dropLast 返回的是除尾元素之外的片段
let array = [1,2,3,4]
print(array.dropLast())//输出[1,2,3]
print(array.dropLast(2))//输出[1,2]
joined(separator: " • ") 数组转换字符串
规定是字符串数组
let arr = ["1","2","3","4","5"]
let string = arr.joined(separator: " • ")
print(string)
firstIndex(where: ) 寻找符合条件的元素并返回数组的index
let index = list.firstIndex(where: {$0.age == 20})
print(index ?? 999)
950
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
