Swift -- 数组高阶函数

map 和 flatMap

都是对对元素进行变换
flatMap会把变换后的元素变成一维数组

// map -- 返回一个数组，其中包含映射给定闭包的结果
let cast = ["Vivien", "Marlon", "Kim", "Karl"]
let lowercaseNames = cast.map { $0.lowercased() }
// 'lowercaseNames' == ["vivien", "marlon", "kim", "karl"]

let lowercaseFlapNames = cast.flatMap { $0.lowercased() }
// 'lowercaseFlapNames' == ["v", "i", "v", "i", "e", "n", "m", "a", "r", "l", "o", "n", "k", "i", "m", "k", "a", "r", "l"]
let letterCounts = cast.map { $0.count }
// 'letterCounts' == [6, 6, 3, 4]


let numbersCompound = [[1,2,3],[4,5,6]];
var res = numbersCompound.map { $0.map{ $0 + 2 } }
// [[3, 4, 5], [6, 7, 8]]
var flatRes = numbersCompound.flatMap { $0.map{ $0 + 2 } }
// [3, 4, 5, 6, 7, 8]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

compactMap

返回一个数组，其中包含调用给定转换并调用此序列的每个元素的非’ nil '结果。

let possibleNumbers = ["1", "2", "three", "///4///", "5"]
 
let compactMapped: [Int] = possibleNumbers.compactMap { str in Int(str) }
// [1, 2, 5]
let mapped: [Int?] = possibleNumbers.map { str in Int(str) }
// [1, 2, nil, nil, 5]

1
2
3
4
5
6
7

filter

将这个数组中符合一定条件的元素过滤出来并用它们创建一个新的数组。

let nums = [1,2,3,4,5,6,7,8,9,10]
nums.filter { num in num % 2 == 0 } 
// [2, 4, 6, 8, 10]
1
2
3

// filter的实现
extension Array {
    func filter(_ isIncluded: (Element) -> Bool) -> [Element] {
        var result: [Element] = []
        for x in self where isIncluded(x) {
            result.append(x)
        }
        return result
    }
}
1
2
3
4
5
6
7
8
9
10

allSatisfy

针对一个条件测试所有元素。
多用于判断集合中的元素谁否都满足这个条件

let names = ["Sofia", "Camilla", "Martina", "Mateo", "Nicolás"]
// 判断集合中的元素的长度是否都大于等于5
let allHaveAtLeastFive = names.allSatisfy({ $0.count >= 5 })
// allHaveAtLeastFive == true
1
2
3
4

reduce

所有元素合并为一个新的单一的值

例如： 把集合中数相加为一个值

let fibs = [0, 1, 1, 2, 3, 5]
let sum = fibs.reduce(0) { total, num in total + num }
 // sum == 12
//或者
let sum = fibs.reduce(0, +) 
1
2
3
4
5

reduce 的输出值的类型不必和元素的类型相同。
举个例子，如果我们想将一个整数列表转换为一个字符串，并且每个数字后面跟一个逗号和空格，那么可以这样

let fibs = [0, 1, 1, 2, 3, 5]
let str = fibs.reduce("") { str, num in str + "\(num), " }
// str == "0, 1, 1, 2, 3, 5"
1
2
3

reduce 的实现是这样的：

extension Array {
    func reduce<Result>(_ initialResult: Result, 
        _ nextPartialResult: (Result, Element) -> Result) -> Result 
    {
        var result = initialResult
        for x in self {
            result = nextPartialResult(result, x)
        }
        return result
    }
}
1
2
3
4
5
6
7
8
9
10
11

forEach

访问每个元素,类似与for in循环
注：forEach 和 for in 的区别
在forEach中使用return并不能中断循环，它仅仅只是让闭包本身返回

let numberWords = ["one", "two", "three"]
        
numberWords.forEach { word in
	print(word)
}
// Prints "one"
// Prints "two"
// Prints "three"
1
2
3
4
5
6
7
8

sort(by:) 和 sorted(by:),

重排元素

var students = ["Kofi", "Abena", "Peter", "Kweku", "Akosua"]
students.sort(by: >)
print(students)
        
// sorted 是有返回值的，生成一个新的数组
let midStu = students.sorted(by: >)
print(midStu)

// Prints "["Peter", "Kweku", "Kofi", "Akosua", "Abena"]"

1
2
3
4
5
6
7
8
9
10

lexicographicallyPrecedes(_:by:)

• 返回一个布尔值，该值指示在字典排序中该序列是否在另一个序列之前
• 使用小于操作符(’ < ')比较元素。调用给定的谓词来比较元素。

let a = [1, 2, 2, 2]
let b = [1, 2, 3, 4]
    
print(a.lexicographicallyPrecedes(b))
// Prints "true"
print(b.lexicographicallyPrecedes(b))
// Prints "false"

1
2
3
4
5
6
7
8

min() 和 max()

找到所有元素中的最小或最大值。

min() 、max()

let heights = [67.5, 65.7, 64.3, 61.1, 58.5, 60.3, 64.9]
let lowestHeight = heights.min()
print(lowestHeight)
// Prints "Optional(58.5)"

let greatestHeight = heights.max()
print(greatestHeight)
// Prints "Optional(67.5)"



1
2
3
4
5
6
7
8
9
10
11

min(by:) 和 max(by:)

返回序列中的最小元素，使用给定谓词作为元素之间的比较。

let hues = ["Heliotrope": 296, "Coral": 16, "Aquamarine": 156]

let leastHue = hues.min { a, b in a.value < b.value } print(leastHue)
// Prints "Optional((key: "Coral", value: 16))"
        
let greatestHue = hues.max { a, b in a.value < b.value }
print(greatestHue)
// Prints "Optional((key: "Heliotrope", value: 296))"
1
2
3
4
5
6
7
8

starts(with: )

判断当前序列的初始元素是否与另一个序列中的元素相同。

let a = 1...3
let b = 1...10
        
print(b.starts(with: a))
// Prints "true"

1
2
3
4
5
6

注：传递一个没有元素或为’ possiblePrefix ‘的空集合的序列总是会得到’ true '。

print(b.starts(with: []))
// Prints "true"
1
2

elementsEqual()

判断两个数组是否相等

  	let a = 1...3
	let b = 1...10
    ///
    print(a.elementsEqual(b))
    // Prints "false"
    print(a.elementsEqual([1, 2, 3]))
    // Prints "true"
1
2
3
4
5
6
7

prefix() 和 prefix(while)

prefix():返回包含集合初始元素的子序列，长度不超过指定的最大长度。

	let numbers = [1, 2, 3, 4, 5]
    print(numbers.prefix(2))
    // Prints "[1, 2]"
    print(numbers.prefix(10))
    // Prints "[1, 2, 3, 4, 5]"
1
2
3
4
5

prefix(while:): 包含闭包返回“false”‘前’的所有元素，原序列不变
如果该元素应该包含在新序列中，则闭包返回“true”；否则返回“false”。一旦返回’ false '它将不会被再次调用。

/// 返回一个新序列：包含闭包返回“false”'前'的所有元素，原序列不变。
///
/// 参数是一个闭包，它接受序列的一个元素作为它的参数，如果该元素应该包含在新序列中，则闭包返回“true”；否则返回“false”。一旦返回' false '它将不会被再次调用。

var numbers = [1, 2, 3, 4, 5, 1, 6, 7, 1, 8, 9]
let prefix = numbers.prefix { (elem) -> Bool in
    if elem < 3 { return true} // 元素应该包含在新序列中，则闭包返回“true”
    return false // 一旦返回' false '它将不会被再次调用。
}
print(prefix)  
// Prints " [1, 2]"
print(numbers) 

// // Prints "[1, 2, 3, 4, 5, 1, 6, 7, 1, 8, 9]"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

dropFirst() 和 drop(while )

``:返回子序列，除给定数量的初始元素外，其余元素全部包含。
如果要删除的元素数量超过集合中的元素数量，则结果是一个空子序列。

	let numbers = [1, 2, 3, 4, 5]
    print(numbers.dropFirst(2))
    // Prints "[3, 4, 5]"
    print(numbers.dropFirst(10))
    // Prints "[]"
1
2
3
4
5

drop(while ):当条件为真时，丢弃元素；一旦不为真，返回其余的元素 (和 prefix 类似，不过返回相反的集合)。

	var numbers = [1, 2, 3, 4, 5, 1, 6, 7, 1, 8, 9]
    let prefix = numbers.drop { (elem) -> Bool in
         if elem < 3 { return true}
         return false //
	}
    print(prefix)
    // Prints " [3, 4, 5, 1, 6, 7, 1, 8, 9] "
    print(numbers)
	// Prints " [1, 2, 3, 4, 5, 1, 6, 7, 1, 8, 9] "
1
2
3
4
5
6
7
8
9

removeAll(where:)

删除所有符合条件的元素

	var numbers = [5, 6, 7, 8, 9, 10, 11]
   	numbers.removeAll(where: { $0 % 2 != 0 })
    // numbers == [6, 8, 10]

	// 也可以传一个集合，删除集合内符合条件的元素
	var phrase = "The rain in Spain stays mainly in the plain."
    ///
    let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
    phrase.removeAll(where: { vowels.contains($0) })
    // phrase == "Th rn n Spn stys mnly n th pln."
1
2
3
4
5
6
7
8
9
10