1
2
3
4
5
6
7
8
9

func greet(_ name: String, from city: String = "北京", times: Int = 1) -> String {
    Array(repeating: "你好，\(name)（来自 \(city)）", count: times).joined(separator: "\n")
}

print(greet("Swift"))
// prints: 你好，Swift（来自 北京）
print(greet("Kotlin", from: "上海", times: 2))
// prints: 你好，Kotlin（来自 上海）
//         你好，Kotlin（来自 上海）

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

func sum(_ values: Int...) -> Int {
    values.reduce(0, +)
}
print(sum(1, 2, 3))
// prints: 6

func double(_ x: inout Int) {
    x *= 2
}
var v = 21
double(&v)
print(v)
// prints: 42

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

// 单一返回值
func square(_ x: Int) -> Int { x * x }

// 元组：一次返回多个值
func minMax(_ a: [Int]) -> (min: Int, max: Int)? {
    guard let lo = a.min(), let hi = a.max() else { return nil }
    return (lo, hi)
}

if let result = minMax([3, 1, 4]) {
    print(result.min, result.max)
}
// prints: 1 4

// 不关心返回值时可以丢弃，但默认会给出警告：
@discardableResult
func log(_ s: String) -> Int { s.count }
log("这行不会产生警告")

1
2
3
4
5
6
7
8
9

func describe(_ n: Int) -> String {
    if n > 0 {          // 多行，但整体是一个 if 表达式
        "正数"
    } else {
        "非正数"
    }
}
print(describe(1), describe(-1))
// prints: 正数 非正数

1
2
3
4

func f(_ n: Int) -> String {
    print("先做点别的")      // ← 有了这一句，函数体就不再是单个表达式
    n > 0 ? "正" : "非正"
}

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

let add: (Int, Int) -> Int = { $0 + $1 }
print(add(2, 3))
// prints: 5

func apply(_ x: Int, transform: (Int) -> Int) -> Int {
    transform(x)
}
print(apply(5) { $0 * $0 })
// prints: 25
print(apply(5, transform: { $0 + 1 }))
// prints: 6

// 嵌套函数：只在外部函数里可见
func outer(_ n: Int) -> Int {
    func twice(_ x: Int) -> Int { x * 2 }
    return twice(n) + 1
}
print(outer(10))
// prints: 21

1
2
3
4

func retry(times: Int, task: () -> Void) { for _ in 0..<times { task() } }

retry(times: 3) { print("尝试") }        // 尾随闭包
retry(times: 3, task: { print("尝试") }) // 等价写法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func configure(setup: () -> Void, completion: () -> Void) {
    setup(); completion()
}

configure {
    print("setup")
} completion: {
    print("completion")
}
// prints: setup
//         completion

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

func isReady() -> Bool { true }
func check(_ body: () -> Bool) -> Bool { body() }

if isReady() {
    print("这是 if 的代码块")
}

if check({ true }) {          // 想传闭包就老老实实写进括号里
    print("显式传参才没有歧义")
}
// prints: 这是 if 的代码块
//         显式传参才没有歧义

1

tc.swift:2:10: warning: trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning

1
2
3
4
5
6
7

func makeCounter() -> () -> Int {
    var count = 0
    return { count += 1; return count }
}
let counter = makeCounter()
print(counter(), counter(), counter())
// prints: 1 2 3

1
2
3
4
5

func perform(_ body: @escaping () -> Void) { body() }

func store(_ body: @escaping () -> Void) -> () -> Void {
    body              // 存起来以后再调用，必须标 @escaping
}

1
2
3

func perform(_ body: @escaping @Sendable () -> Void) { body() }
perform { print("sendable ok") }
// prints: sendable ok

 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
29
30
31
32

// 1. 默认值每次调用都重算
func demo() {
    final class Ticker {                     // 局部类，只为让输出可预测
        var n = 0
        func next() -> Int { n += 1; return n }
    }
    let ticker = Ticker()

    func f(x: Int = ticker.next()) -> Int { x }
    print(f(), f(), f())
}
demo()
// prints: 1 2 3      每调一次 f()，默认值表达式就重新求值一次

// 2. for-in 的循环变量每轮都是新的
var fns: [() -> Void] = []
for i in 0..<3 { fns.append { print(i) } }
fns.forEach { $0() }
// prints:
//   0
//   1
//   2

// 对照：循环外那个 var 才是共享的
var shared = 0
var fns2: [() -> Void] = []
for _ in 0..<3 { fns2.append { print(shared) }; shared += 1 }
fns2.forEach { $0() }
// prints:
//   3
//   3
//   3

1
2
3
4
5
6
7
8
9

func assertTrue(_ condition: @autoclosure () -> Bool, _ message: String = "") {
    if !condition() {
        print("断言失败: \(message)")
    }
}

assertTrue(1 + 1 == 2)                    // 传表达式的样子
assertTrue(1 + 1 == 3, "数学崩了")
// prints: 断言失败: 数学崩了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

let people = [(name: "Bob", age: 25), (name: "Alice", age: 30)]

print(people.map(\.name))
// prints: ["Bob", "Alice"]
print(people.map(\.name).sorted())
// prints: ["Alice", "Bob"]
print([3, 1, 2].sorted(by: >))
// prints: [3, 2, 1]
print([3, 1, 2].reduce(0, +))
// prints: 6

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

enum ParseError: Error { case bad }

func measure(_ work: () throws -> Int) rethrows -> Int {
    try work()
}

print(measure { 42 })
// prints: 42               闭包不抛错，调用点连 try 都不用写

do {
    let n = try measure { throw ParseError.bad }
    print(n)
} catch {
    print("接住了 \(error)")
}
// prints: 接住了 bad       闭包抛错，调用点就必须 try

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

// 一个"老"函数：签名写的是 @escaping，其实只在内部同步用完
func legacyMap(_ values: [Int], _ transform: @escaping (Int) -> Int) -> [Int] {
    values.map(transform)
}

// 我们的参数是非逃逸的，直接转发会编译不过
func doubled(_ values: [Int], using transform: (Int) -> Int) -> [Int] {
    withoutActuallyEscaping(transform) { escaping in
        legacyMap(values, escaping)
    }
}

print(doubled([1, 2, 3], using: { $0 * 2 }))
// prints: [2, 4, 6]