1
2
3
4
5
6
7

let pi = 3.14159        // 常量，赋值一次就锁死
var count = 0           // 变量，可以再改
count += 1

let explicit: Double = 1        // 显式类型注解
let a = 1, b = 2, c = 3         // 一行声明多个
var x = 0, y = 0

1
2
3
4
5
6
7
8

let i = 1
let d = 3.0
// let bad = i + d            // 🛑 error: binary operator '+' cannot be applied to operands of type 'Int' and 'Double'
let ok = Double(i) + d        // ✅ 必须显式转换
let truncated = Int(d)        // 3，浮点转整数是截断而非四舍五入

let s = "42"
let parsed = Int(s)           // Int? 而不是 Int —— 转换可能失败

1
2
3
4
5
6

print(Int.max)
// prints: 9223372036854775807
print(Int.max &+ 1)
// prints: -9223372036854775808
print(Int8.max, Int8.min, UInt8.max)
// prints: 127 -128 255

1
2
3
4

print((1, "b") < (2, "a"))
// prints: true     先比第一个元素，不等就不再往后看
print((1, "b") < (1, "c"))
// prints: true     第一个相等，才继续比第二个

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

let n = 7

print(3 ~= 3)          // prints: true
print(1...10 ~= n)     // prints: true
print(0..<5 ~= n)      // prints: false

switch n {
case 1...10: print("命中区间")    // 等价于 if 1...10 ~= n
default:     print("没命中")
}
// prints: 命中区间

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

struct MultipleOf { let base: Int }

// 参数顺序是 (模式, 待匹配的值)
func ~= (pattern: MultipleOf, value: Int) -> Bool {
    value % pattern.base == 0
}

switch 9 {
case MultipleOf(base: 3): print("3 的倍数")
case MultipleOf(base: 2): print("2 的倍数")
default:                  print("都不是")
}
// prints: 3 的倍数

print(MultipleOf(base: 3) ~= 9)
// prints: true

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

var x = Int.max
x &+= 1
print(x)
// prints: -9223372036854775808     加到顶了，从最小那头绕回来

var y = Int.min
y &-= 1
print(y)
// prints: 9223372036854775807     减到底了，从最大那头绕回来

var z = Int.max
z &*= 2
print(z)
// prints: -2                       0x7FFF...FF × 2 只留低 64 位，符号位成了 1

1
2
3
4
5

var flags: UInt8 = 0b0000_1111
flags <<= 4
flags |= 0b0000_0001
print(flags, flags >> 4)
// prints: 241 15

1
2
3
4
5
6

var a: Int8 = 100
a <<= 3
var b: Int8 = 100
b &<<= 3
print(a, b)
// prints: 32 32                    没移过头时，两者完全一样

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

var c: Int8 = 1
c <<= 8
print(c)
// prints: 0                        移过头了，聪明移位给个 0

var d: Int8 = 1
d &<<= 8
print(d)
// prints: 1                        8 & 7 = 0，等于原地没动

var e: Int8 = 1
e &<<= 9
print(e)
// prints: 2                        9 & 7 = 1，只左移 1 位

var f: Int8 = -4
f >>= 9
print(f)
// prints: -1                       右移补符号位，负数最后被填成 -1

var g: Int8 = -4
g &>>= 9
print(g)
// prints: -2                       9 & 7 = 1，等价于 >> 1

1
2
3
4
5
6
7

print(2 + 3 * 4)          // prints: 14
print(1 | 2 & 4)          // prints: 1      & 比 | 高
print(1 << 2 + 3)         // prints: 7      移位比加法高
print(true || false && false)   // prints: true   && 比 || 高

let nothing: Int? = nil
print(nothing ?? 0 + 1)   // prints: 1      ?? 比 + 低，右边先算完

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import Foundation

infix operator **: MultiplicationPrecedence

func ** (base: Double, exp: Double) -> Double {
    pow(base, exp)
}

print(2 ** 10)
// prints: 1024.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import Foundation

prefix operator √
prefix func √ (x: Double) -> Double { x.squareRoot() }

postfix operator °
postfix func ° (x: Double) -> Double { x * .pi / 180 }

print(√16.0, 180.0°)
// prints: 4.0 3.141592653589793

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

precedencegroup PowerPrecedence {
    higherThan: MultiplicationPrecedence   // 比乘法更紧
    associativity: right                   // 右结合
}

infix operator **: PowerPrecedence

func ** (base: Int, exp: Int) -> Int {
    var result = 1
    for _ in 0..<exp { result *= base }
    return result
}

print(2 ** 3 ** 2)
// prints: 512     右结合，等于 2 ** (3 ** 2)
print(2 * 3 ** 2)
// prints: 18      比乘法紧，等于 2 * (3 ** 2)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

let nums = [10, 20, 30, 40, 50]
print(nums[2...])         // prints: [30, 40, 50]
print(nums[...2])         // prints: [10, 20, 30]
print(nums[..<2])         // prints: [10, 20]
print((1...10).contains(7))   // prints: true

print(Array(stride(from: 0, to: 10, by: 3)))
// prints: [0, 3, 6, 9]
print(Array(stride(from: 10, through: 0, by: -3)))
// prints: [10, 7, 4, 1]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

let score = 87

if score >= 90 {
    print("A")
} else if score >= 80 {
    print("B")
} else {
    print("C")
}
// prints: B

1
2
3
4
5
6
7
8

func process(_ input: String?) {
    guard let text = input, !text.isEmpty else {
        print("输入无效")
        return
    }
    // 从这里开始 text 是非可选 String，不用再解包
    print(text.count)
}

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

let point = (x: 2, y: 0)

switch point {
case (0, 0):
    print("原点")
case (let x, 0):
    print("在 x 轴上，x = \(x)")
case (0, let y):
    print("在 y 轴上，y = \(y)")
case let (x, y) where x == y:
    print("对角线")
case let (x, y):
    print("普通点 (\(x), \(y))")
}
// prints: 在 x 轴上，x = 2

1
2
3
4
5
6
7
8
9

let score = 87

switch score {
case 90...:      print("A")
case 80..<90:    print("B")
case 60..<80:    print("C")
default:         print("F")
}
// prints: B

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

let n = 5
let parity = if n.isMultiple(of: 2) { "偶数" } else { "奇数" }
print(parity)
// prints: 奇数

let grade = 87
let letter = switch grade {
case 90...:   "A"
case 80..<90: "B"
default:      "C"
}
print(letter)
// prints: B

1
2
3
4
5

for i in 0..<3 { print(i) }         // 0 1 2
for (index, value) in [10, 20].enumerated() { print(index, value) }
for (key, value) in ["a": 1, "b": 2] { print(key, value) }   // 字典顺序不保证
for _ in 0..<3 { print("重复三次") }  // _ 表示不关心这个值
for c in "abc" { print(c) }          // Character

1
2
3
4
5

var i = 0
while i < 3 { i += 1 }         // 先判断，可能一次都不执行

var j = 0
repeat { j += 1 } while j < 3  // 至少执行一次

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

outer: for i in 1...3 {
    for j in 1...3 {
        if j == 2 { continue }      // 跳过本次内层循环
        if i == 3 { break outer }   // 直接跳出外层循环
        print(i, j)
    }
}
// prints:
//   1 1
//   1 3
//   2 1
//   2 3

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

let values = [1, 2, 3]

outer: if values.count == 3 {
    for v in values {
        if v == 2 { break outer }      // 直接跳出整个 if 块
        print("处理", v)
    }
    print("不会到这里")
}
// prints: 处理 1
print("继续后面的代码")
// prints: 继续后面的代码

1
2
3
4
5
6

block: do {
    print("第一步")
    break block                      // 想提前收工时把它放在中间
    // print("这行不会执行")
}
// prints: 第一步

1
2
3
4
5
6
7
8

let rawInput: String? = "42"

if let value = Int(rawInput ?? "") {
    print("解析成功：\(value)")
} else {
    print("解析失败")
}
// prints: 解析成功：42

1
2
3
4
5
6

let nickname: String? = "小龟"

if let nickname {          // 等价于 if let nickname = nickname
    print("你好，\(nickname)")
}
// prints: 你好，小龟

1
2
3
4
5
6
7

func greet(_ name: String?) -> String {
    guard let name else { return "没有名字" }   // 没值就立刻离开当前作用域
    return "你好，\(name)"                     // 从这里往下，name 已经是 String，不用再解包
}

print(greet("Swift"), greet(nil))
// prints: 你好，Swift 没有名字

1
2
3
4
5
6
7
8

var stack = [1, 2, 3]
while let top = stack.popLast() {
    print(top)
}
// prints:
//   3
//   2
//   1

1
2
3
4
5
6
7
8
9

var head: Int? = 3
while let h = head, h > 0 {
    print(h)
    head = h - 1
}
// prints:
//   3
//   2
//   1

1
2
3
4
5
6
7

let settings: [String: Int]? = ["port": 80]

if var s = settings {          // s 是解包出来的副本
    s["port"] = 8080
    print(s["port"] ?? 0, settings?["port"] ?? 0)
}
// prints: 8080 80

1
2
3
4
5
6
7

func double(_ input: Int?) -> Int {
    guard var x = input else { return -1 }
    x *= 2
    return x
}
print(double(21), double(nil))
// prints: 42 -1

1
2
3
4
5
6
7
8
9

let a: Int? = 1
let b: Int? = nil

if let a, let b, a < b {
    print("a < b")
} else {
    print("前两段有一个是 nil，第三段根本没机会执行")
}
// prints: 前两段有一个是 nil，第三段根本没机会执行

1
2
3
4
5
6
7

@available(macOS 13, *)
func modern() -> Int { 9 }

if #available(macOS 13, *), let v = Optional(modern()) {
    print(v)
}
// prints: 9

1
2
3
4

if let v = Optional(modern()), #available(macOS 13, *) {
   🛑 error: 'modern()' is only available in macOS 13 or newer
      note: add 'if #available' version check
}

1
2
3
4
5
6
7

enum Status { case ok(Int), failed }
let s = Status.ok(200)

if case let .ok(code) = s {
    print("code", code)
}
// prints: code 200

1
2
3
4
5
6

let maybe: Int? = 7

if case let x? = maybe {          // 等价于 if case .some(let x) = maybe
    print("有值：\(x)")
}
// prints: 有值：7

1
2
3
4
5
6

let row: [Int?] = [1, nil, 3]
var picked: [Int] = []

for case let x? in row { picked.append(x) }
print(picked)
// prints: [1, 3]

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

func describe(_ pair: (Int, Int)) -> String {
    switch pair {
    case let (x, y) where x < y: "升序 \(x) \(y)"
    case let (x, y) where x > y: "降序 \(x) \(y)"
    default:                     "相等"
    }
}
print(describe((1, 2)), describe((3, 1)), describe((2, 2)))
// prints: 升序 1 2 降序 3 1 相等

func name(of code: Int?) -> String {
    switch code {
    case let v?: "有值：\(v)"      // 有值就绑定到 v
    case nil:    "没有值"
    }
}
print(name(of: 404), name(of: nil))
// prints: 有值：404 没有值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

enum NetworkError: Error { case timeout(Int) }

do {
    throw NetworkError.timeout(30)
} catch let e as NetworkError {
    print(e)
} catch {
    print("其他错误")
}
// prints: timeout(30)

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

enum Step { case next(Int), done }
let steps: [Step] = [.next(1), .next(2), .next(3), .done]

var i = 0
while case .next(let n) = steps[i] {    // 只要这一项还是 .next 就继续
    print(n)
    i += 1
}
print("停在 \(steps[i])")
// prints:
//   1
//   2
//   3
//   停在 done

1
2
3
4
5
6

func check(_ v: Int?) -> String {
    guard case let v? = v else { return "空" }
    return "有 \(v)"
}
print(check(5), check(nil))
// prints: 有 5 空

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

enum FileError: Error { case missing(String), denied(String) }

do {
    throw FileError.missing("a.txt")
} catch let e where e is FileError {
    print("带 where 的 catch:", e)
} catch {
    print("其他")
}
// prints: 带 where 的 catch: missing("a.txt")

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

enum Status { case ok, failed(code: Int) }

let s = Status.failed(code: 500)

if case .failed(let code) = s, code >= 500 {
    print("服务端错误 \(code)")
}
// prints: 服务端错误 500

func mustBeOK(_ s: Status) {
    guard case .ok = s else { return }
    print("一切正常")
}

let list: [Int?] = [1, nil, 3]
for case let value? in list {      // 只处理非 nil 的元素
    print(value)
}
// prints:
//   1
//   3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func work() {
    defer { print("第二个执行") }
    defer { print("第一个执行") }
    print("主体")
}
work()
// prints:
//   主体
//   第一个执行
//   第二个执行