1、indices（数组遍历索引）
let list = ["1", "2", "3"]
for index in list.indices {
print(index)
}
// 0 1 2
2、enumerated (数组遍历索引及元素)
let list = ["A", "B", "C"]
for (index, item) in list.enumerated() {
print(index, item)
}
// 0 1
// 1 2
// 2 3
3、stride(from: to: by)
//最后一个值小于to的值
for index in stride(from:0, to:12, by:3) {
print(index)
}
// print 0, 3, 6, 9
//最后一个值大于to的值
for index in stride(from:12, to:0, by:-3) {
print(index)
}
// print 12, 9, 6, 3
4、stride(from: through: by)
//最后一个值小于等于through的值
for index in stride(from: 0, through: 12, by: 3) {
print(index)
}
// print 0, 3, 6, 9, 12
//最后一个值大于等于through的值
for index in stride(from: 12, through: 0, by: -3) {
print(index)
}
// print 12, 9, 6, 3, 0
5.map(对集合中的所有元素进行同样的操作，并返回一个新集合)
let nums = [1,2,3]
var mapNums = nums.map {
$0 + 1
}
print("mapNums:\(mapNums)")
// 2 3 4
6.flatMap(可将集合中的所有集合取出，最终变成一个新的集合)
let numFlat = [[1,2,3,4],[8,9,7,6]]
let numsFlatMap = numFlat.flatMap {
$0
}
print("numsFlatMap:\(numsFlatMap)")
// [1,2,3,4,8,9,7,6]
7.CompactMap(当集合中有nil存在时使用CompactMap函数)
let nums = [1,2,nil,3,4,5,6,7,8,nil,nil]
let compactMapNums = nums.compactMap {
$0
}
print("compactMapNums:\(compactMapNums)")
// [1,2,3,4,5,6,7,8]
8.filter(对集合中的元素进行过滤，返回一个符合条件新的集合)
let nums = [1,2,3,4,5,6,7,8]
var filterNums = nums.filter {
$0 < 5
}
print("filterNums:\(filterNums)")
// [1,2,3,4]
9.reduce(对集合中所有的元素进行操作，并返回一个新值)
reduce函数传入什么类型就要返回什么类型
reduce函数有两个参数,$0为上一个的结果值,$1为集合中的元素
let nums = [1,2,3,4]
let reduceNums = nums.reduce([Int]()) {
[$1] + $0
}
print("reduceNums:\(reduceNums)")
// [4,3,2,1]
案例：
// 求数组中元素的平方和
let nums = [1,2,3,4]
let numTemp = nums.filter {
$0 % 2 == 0
}.reduce(Int()) {
$0 + $1 * $1
}
print("numTemp:\(numTemp)")
// 20
// 快速排序算法（使用递归）
extension Array where Element: Comparable {
func quickSorted() -> [Element] {
if self.count > 1 {
let (pivot, remaining) = (self[0], dropFirst())
let lhs = remaining.filter{ $0 <= pivot}
let rhs = remaining.filter{ $0 > pivot}
return lhs.quickSorted() + [pivot] + rhs.quickSorted()
}
return self
}
}
print([1,2,33,22,1,2,3].quickSorted())
// [1, 1, 2, 2, 3, 22, 33]
10.dropFirst、dropLast
dropFirst() 除了数组中第一个元素以外的元素
dropFirst(3) 除了数组中第0-3个元素以外的元素
dropLast() 除了数组中最后一个元素以外的元素
dropLast(3) 除了数组中后3个元素(根据需要写)以外的其他元素
let demoAArr = [1,2,3,4]
print(demoAArr.dropFirst())
// [2,3,4] 其他同理
11.数组 removeAll(where:) — 删除
高效根据条件删除，比filter内存效率高，指定不想要的东西，而不是想要的东西,和filter类似的功能。filter把满足条件的返回到新的数组。不是在操作原数组。removeAll(where:)是操作原数组把满足条件的剔除掉。可根据需求合理选择使用filter和removeAll(where:)
var demoAArr = [1,2,3,4]
demoAArr.removeAll(where: { $0 % 2 == 0 })
print(demoAArr)
// [1, 3]
12. 将一个一维数组以某个长度分割为二维数组
[1,2,3,4,5,6] - [[1,2,3],[4,5,6]]
extension Array {
func chunked(into size: Int) -> [[Element]] {
stride(from: 0, to: count, by: size).map {
Array(self[$0..<Swift.min($0 + size, count)])
}
}
}
let array = [1, 2, 3, 4, 5, 6]
let result = array.chunked(into: 3)
print(result) // [[1,2,3], [4,5,6]]
// 或者 zip函数
let array = [1, 2, 3, 4, 5, 6, 7]
let result = stride(from: 0, to: array.count, by: 3).map {
(zip([0, 1, 2], [$0, $0 + 1, $0 + 2])
.compactMap { $1 < array.count ? array[$1] : nil })
}
print(result) // [[1, 2, 3], [4, 5, 6]]
13. randomElement
例：从一个数组随机取不重复的元素知道数组去完，然后在从原数组里随机取
struct UniqueElementGenerator<Element> {
var originalElements: [Element]
var elements: [Element]
var generator = SystemRandomNumberGenerator()
init(elements: [Element]) {
self.originalElements = elements
self.elements = elements
}
mutating func nextElement() -> Element? {
if elements.isEmpty {
elements = originalElements // 如果元素已经空了，那么重置数组
}
let index = elements.indices.randomElement(using: &generator)!
return elements.remove(at: index)
}
}
var uniqueGenerator = UniqueElementGenerator(elements: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
for _ in 1...15 {
if let number = uniqueGenerator.nextElement() {
print(number) // 会打印 1 到 10 的随机排列，如果元素取完，将从头开始
}
}
14、ExpressibleByDictionaryLiteral 与 ExpressibleByArrayLiteral，ExpressibleByStringLiteral协议
1、ExpressibleByDictionaryLiteral 是 Swift 中的一个协议，允许自定义类型使用字典文字初始化。这个协议可以在你有一组键值对时简化类型的初始化
// 过滤字典中value为nil的例子
struct JSONBodyDictionary: ExpressibleByDictionaryLiteral {
public typealias Key = String
public typealias Value = Any?
public let dictionary: [Key: Any]
public init(_ dictionary: [Key: Value]) {
self.dictionary = dictionary.compactMapValues { $0 }
}
public init(dictionaryLiteral elements: (Key, Value)...) {
dictionary = .init(
uniqueKeysWithValues: elements.compactMap { key, value in
if let value {
(key, value)
} else {
nil
}
}
)
}
}
2、ExpressibleByArrayLiteral是 Swift 标准库中的一个协议，它允许类型通过数组字面量进行初始化。实现这个协议的类型可以由在代码中直接写出的数组字面量来创建和初始化。这意味着你可以定义一个类型，并允许它直接被数组的形式来构造
// 定义一个结构体 `SimpleArray`，它可以通过数组字面量来初始化
struct SimpleArray: ExpressibleByArrayLiteral {
let elements: [Int]
// 实现这个初始化器，当使用数组字面量初始化 `SimpleArray` 时会被调用
init(arrayLiteral elements: Int...) {
self.elements = elements
}
}
// 现在你可以使用数组字面量初始化 `SimpleArray`：
let simpleArray: SimpleArray = [1, 2, 3, 4, 5]
print(simpleArray.elements) // 输出: [1, 2, 3, 4, 5]
// 过滤数组中元素为nil的
struct JSONBodyArray: ExpressibleByArrayLiteral {
public typealias ArrayLiteralElement = Any?
public let array: [Any]
public init(_ array: [ArrayLiteralElement]) {
self.array = array.compactMap { $0 }
}
public init(arrayLiteral elements: ArrayLiteralElement...) {
array = elements.compactMap { $0 }
}
}
3、ExpressibleByStringLiteral 字面量初始化
// 定义一个简单的结构体 `SimpleString`，它可以通过字符串字面量来初始化
struct SimpleString: ExpressibleByStringLiteral {
let value: String
// 实现这个初始化器，当使用字符串字面量初始化 `SimpleString` 时会被调用
init(stringLiteral value: String) {
self.value = value
}
}
// 现在你可以使用字符串字面量初始化 `SimpleString`：
let simple: SimpleString = "Hello, World!"
print(simple.value) // 输出："Hello, World!"
