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

import Foundation

struct Money {
    var cents: Int
}

extension Money {
    var yuan: Double { Double(cents) / 100 }        // ✅ 计算属性
    // var rate: Double = 0.06                      // ❌ 报错：extensions must not contain stored properties
}

print(Money(cents: 1999).yuan)
// prints: 19.99

1
2

error: 'lazy' cannot be used on a let
error: 'lazy' cannot be used on an already-lazy global

1
2
3
4
5
6

import Foundation

@MainActor
final class SessionCache {
    static var shared: [String: String] = [:]     // 加了 @MainActor 才能这么写
}

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

import Foundation

@propertyWrapper
struct Clamped {
    private var value: Int
    let range: ClosedRange<Int>

    init(wrappedValue: Int, _ range: ClosedRange<Int>) {
        self.range = range
        self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }

    var wrappedValue: Int {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }

    var projectedValue: String { "允许范围 \(range)" }
}

struct Player {
    @Clamped(0...100) var health = 80
}

var player = Player()
player.health = 150
print(player.health, player.$health)
// prints: 100 允许范围 0...100

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

import Foundation

// 静态下标：类型本身就能被下标访问
enum Suit: String, CaseIterable {
    case spade, heart, diamond, club

    static subscript(index: Int) -> Suit? {
        let all = Suit.allCases
        guard all.indices.contains(index) else { return nil }
        return all[index]
    }
}

print(Suit[2]?.rawValue as Any, Suit[9] as Any)
// prints: Optional("diamond") nil

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

import Foundation

// 多参数 + 默认参数：既能 grid[3, 4] 也能 grid[5]
struct Grid {
    private var cells = Array(repeating: 0, count: 100)

    subscript(row: Int, column: Int = 0) -> Int {
        get { cells[row * 10 + column] }
        set { cells[row * 10 + column] = newValue }
    }
}

var grid = Grid()
grid[3, 4] = 7
grid[5] = 9
print(grid[3, 4], grid[5], grid[5, 0])
// prints: 7 9 9

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

import Foundation

// 用参数标签给"同一个下标"加语义：bag[0] 会崩，bag[safe: 0] 不会
struct Bag<Element> {
    private var items: [Element] = []

    mutating func append(_ item: Element) { items.append(item) }

    subscript(safe index: Int) -> Element? {
        items.indices.contains(index) ? items[index] : nil
    }
}

var bag = Bag<Int>()
bag.append(1)
print(bag[safe: 0] as Any, bag[safe: 5] as Any)
// prints: Optional(1) nil

1
2
3
4
5
6

import Foundation

protocol TwoDimensional {
    associatedtype Element
    subscript(row: Int, column: Int) -> Element { get set }
}

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

import Foundation

@dynamicMemberLookup
struct JSON {
    private var storage: [String: JSON] = [:]
    var stringValue: String?

    init(stringValue: String? = nil) { self.stringValue = stringValue }

    subscript(dynamicMember key: String) -> JSON {
        get { storage[key] ?? JSON() }
        set { storage[key] = newValue }
    }
}

var doc = JSON()
doc.user.name = JSON(stringValue: "Mia")
print(doc.user.name.stringValue as Any, doc.missing.stringValue as Any)
// prints: Optional("Mia") nil