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

struct Permissions: OptionSet {
    let rawValue: Int
    static let read    = Permissions(rawValue: 1 << 0)
    static let write   = Permissions(rawValue: 1 << 1)
    static let execute = Permissions(rawValue: 1 << 2)
}

let p: Permissions = [.read, .write]          // 组合就是数组字面量
print(p.rawValue, p.contains(.read), p.contains(.execute))
// prints: 3 true false

print(Permissions.write.union(.execute).rawValue)
// prints: 6
print(p.subtracting(.read).rawValue)
// prints: 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import Foundation   // KeyPathComparator 在 Foundation 里

struct User { let name: String; let age: Int }
let users = [User(name: "Bob", age: 25), User(name: "Alice", age: 30)]

print(users.map(\.name))
// prints: ["Bob", "Alice"]
print(users.sorted(using: KeyPathComparator(\.age)).map(\.name))
// prints: ["Bob", "Alice"]
print(users.sorted { $0.age < $1.age }.map(\.name))
// prints: ["Bob", "Alice"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import Foundation

struct User { let name: String; let age: Int }   // 纯 Swift 结构体
// print(#keyPath(User.name))
// 🛑 error: argument of '#keyPath' refers to non-'@objc' property 'name'

final class ObjcUser: NSObject {
    @objc var name: String = "x"
}
print(#keyPath(ObjcUser.name))
// prints: name

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import Foundation

struct Config: Codable, Equatable {
    var name: String
    var timeout: Int

    enum CodingKeys: String, CodingKey {
        case name = "app_name"     // 映射到 JSON 里的另一个键名
        case timeout
    }
}

let encoder = JSONEncoder()
encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
let data = try encoder.encode(Config(name: "demo", timeout: 30))
print(String(decoding: data, as: UTF8.self))
// prints: {
//           "app_name" : "demo",
//           "timeout" : 30
//         }

print(try JSONDecoder().decode(Config.self, from: data))
// prints: Config(name: "demo", timeout: 30)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import Foundation

struct Event: Codable { var title: String; var date: Date }

let iso = JSONEncoder()
iso.dateEncodingStrategy = .iso8601
iso.outputFormatting = [.sortedKeys]      // 不写这行，键的顺序每次都可能不一样
let payload = try iso.encode(Event(title: "发布", date: Date(timeIntervalSince1970: 0)))
print(String(decoding: payload, as: UTF8.self))
// prints: {"date":"1970-01-01T00:00:00Z","title":"发布"}

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

import Foundation

let now = Date()
print(now.formatted(date: .abbreviated, time: .shortened))

let duration = Duration.seconds(90)
print(duration.formatted(.units(allowed: [.minutes, .seconds])))
// prints: 1分钟30秒

let clock = ContinuousClock()
let elapsed = clock.measure { _ = (1...10_000).reduce(0, +) }
print(elapsed > .zero)
// prints: true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import Foundation

struct A: Codable {
    var a: Int
    var b: Int = 0                            // 有默认值，才敢从 CodingKeys 里去掉
    enum CodingKeys: String, CodingKey { case a }
}

let data = Data(#"{"a":1,"b":2}"#.utf8)
print(try JSONDecoder().decode(A.self, from: data))
// prints: A(a: 1, b: 0)       JSON 里的 b 被整个忽略，留下的 0 是属性默认值

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

@resultBuilder
struct ArrayBuilder {
    static func buildBlock(_ parts: [Int]...) -> [Int] { parts.flatMap { $0 } }
    static func buildOptional(_ part: [Int]?) -> [Int] { part ?? [] }
}

func collect(@ArrayBuilder _ body: () -> [Int]) -> [Int] { body() }

let flag = false
let built = collect {
    [1, 2]
    if flag { [99] }      // 条件分支也能写进来
    [3]
}
print(built)
// prints: [1, 2, 3]

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

let numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(numbers.prefix(while: { $0 > 2 }).map { $0 })
// prints: [3]

var mutable = [3, 1, 4, 1, 5]
let pivot = mutable.partition(by: { $0 >= 4 })
print(mutable, pivot)
// prints: [3, 1, 1, 4, 5] 3
// pivot 是分界下标：前半段都不满足条件，后半段都满足，但**组内顺序不作保证**

// zip 的长度以较短的那个为准
print(Array(zip(1..., ["a", "b", "c"])))
// prints: [(1, "a"), (2, "b"), (3, "c")]

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

import Observation

@Observable
final class Model {
    var name = ""                                  // 被观察
    @ObservationIgnored var cache = 0              // 改了也不通知视图
}

let m = Model()
m.name = "x"
print(m.name, m.cache)
// prints: x 0

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

import Foundation

UserDefaults.standard.set(42, forKey: "launchCount")
print(UserDefaults.standard.integer(forKey: "launchCount"))
// prints: 42

let note = Notification.Name("demo")
let token = NotificationCenter.default.addObserver(forName: note, object: nil, queue: nil) { n in
    print("收到通知:", n.userInfo?["k"] ?? "-")
}
NotificationCenter.default.post(name: note, object: nil, userInfo: ["k": 7])
// prints: 收到通知: 7
NotificationCenter.default.removeObserver(token)

print(Bundle.main.executablePath != nil)
// prints: true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import CryptoKit
import Foundation

let data = Data("你好".utf8)
let base64 = data.base64EncodedString()
print(base64, String(data: Data(base64Encoded: base64)!, encoding: .utf8)!)
// prints: 5L2g5aW9 你好

print(SHA256.hash(data: Data("abc".utf8)).map { String(format: "%02x", $0) }.joined())
// prints: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad