Swift 常量详解：从基础语法到实战应用

1. 引言

在 Swift 编程语言中，常量是构建安全、可维护代码的基础概念之一。与变量不同，常量一旦赋值便不可修改，这种特性不仅有助于防止意外修改数据，还能让编译器进行更积极的优化。本文将深入探讨 Swift 常量的定义、使用场景、与变量的区别，并通过丰富的代码实例帮助读者全面掌握这一核心知识点。

2. 常量的基本语法

在 Swift 中，使用 let 关键字来声明常量。声明常量时必须进行初始化，且初始化后不能再改变其值。以下是常量的基本声明方式：

let constantName: Type = value

其中，Type 可以省略，Swift 会根据赋值自动推断类型。下面通过几个简单示例来演示：

// 显式指定类型
let maxLoginAttempts: Int = 5

// 类型推断
let pi = 3.14159
let appName = "MyApp"
let isProduction = true

print(maxLoginAttempts) // 输出: 5
print(pi)               // 输出: 3.14159
print(appName)          // 输出: MyApp
print(isProduction)     // 输出: true

3. 常量与变量的区别

Swift 中变量使用 var 关键字声明，其值可以被修改；而常量使用 let 声明，值一旦确定便不可更改。理解两者的区别对于编写正确、高效的代码至关重要。

下面通过代码对比两者的行为差异：

// 变量：值可以修改
var currentScore = 100
currentScore = 150
print(currentScore) // 输出: 150

// 常量：值不可修改
let maxScore = 100
// maxScore = 150 // 编译错误: Cannot assign to value: 'maxScore' is a 'let' constant

从上面的例子可以看出，尝试修改常量会直接导致编译错误，这有助于在开发阶段就发现潜在的问题。

4. 常量的类型推断

Swift 是一门类型安全的语言，同时也具备强大的类型推断能力。使用 let 声明常量时，编译器会根据初始值自动推断常量的类型，无需显式标注。这在简化代码的同时保持了类型安全。

// 类型推断示例
let integerNumber = 42          // 推断为 Int
let doubleNumber = 3.14         // 推断为 Double
let stringText = "Hello"        // 推断为 String
let booleanValue = false        // 推断为 Bool
let characterValue = "A"        // 推断为 Character

// 使用 type(of:) 验证推断结果
print(type(of: integerNumber))  // 输出: Int
print(type(of: doubleNumber))   // 输出: Double
print(type(of: stringText))     // 输出: String
print(type(of: booleanValue))   // 输出: Bool

需要注意的是，当需要特定类型时，仍可以显式标注类型，避免推断结果与预期不符：

// 显式指定类型，避免默认推断为 Int
let preciseValue: Double = 10
print(preciseValue) // 输出: 10.0

5. 常量的命名规范

良好的命名规范能显著提升代码的可读性。Swift 常量命名遵循驼峰命名法（camelCase），首字母小写，后续单词首字母大写。同时，命名应具有描述性，能够清晰表达常量的用途。

// 推荐的命名方式
let maxRetryCount = 3
let defaultUserName = "guest"
let apiBaseURL = "https://api.example.com"
let isUserLoggedIn = false

// 不推荐的命名方式
// let max = 3
// let name = "guest"
// let url = "https://api.example.com"

此外，Swift 支持使用 Unicode 字符作为常量名，但为了代码的可维护性和团队协作，建议使用英文命名。

6. 常量的作用域

常量的作用域决定了它在代码中的可见范围。Swift 中的常量可以是全局常量、局部常量或类型属性，不同作用域的常量有不同的生命周期和访问方式。

6.1 全局常量

在函数、方法或类外部声明的常量称为全局常量，可以在整个模块中访问：

// 全局常量
let globalAppVersion = "1.0.0"

func printVersion() {
    print("App 版本: \(globalAppVersion)")
}

printVersion() // 输出: App 版本: 1.0.0

6.2 局部常量

在函数或代码块内部声明的常量称为局部常量，只能在声明它的作用域内访问：

func calculateArea() {
    // 局部常量
    let pi = 3.14159
    let radius = 5.0
    let area = pi * radius * radius
    print("圆的面积: \(area)")
}

calculateArea() // 输出: 圆的面积: 78.53975

// 以下代码会报错，因为 pi 是局部常量
// print(pi) // 编译错误: Cannot find 'pi' in scope

6.3 类型属性

使用 static let 可以在类型中定义常量属性，这些常量属于类型本身，而非某个实例：

struct AppConfig {
    static let appName = "SwiftDemo"
    static let maxFileSize = 1024 * 1024 // 1MB
}

print(AppConfig.appName)      // 输出: SwiftDemo
print(AppConfig.maxFileSize)  // 输出: 1048576

7. 常量与元组

Swift 的元组（Tuple）可以将多个值组合成一个复合值。使用 let 声明元组常量时，可以一次性解构多个值，这在函数返回多个结果时非常实用。

// 声明元组常量
let userInfo = ("张三", 25, "developer")
print(userInfo.0) // 输出: 张三
print(userInfo.1) // 输出: 25
print(userInfo.2) // 输出: developer

// 元组解构
let (name, age, job) = userInfo
print("姓名: \(name), 年龄: \(age), 职业: \(job)")
// 输出: 姓名: 张三, 年龄: 25, 职业: developer

// 使用下划线忽略不需要的值
let (_, _, onlyJob) = userInfo
print("职业: \(onlyJob)") // 输出: 职业: developer

8. 常量与可选类型

可选类型（Optional）是 Swift 处理值缺失的重要机制。常量同样可以是可选类型，在声明时可以不立即赋值，但一旦赋值后便不可更改。

// 可选常量
let optionalValue: Int? = nil
print(optionalValue) // 输出: nil

// 可选常量可以赋值为具体值
let anotherOptional: String? = "Hello"
print(anotherOptional) // 输出: Optional("Hello")

// 使用可选绑定安全解包
if let unwrapped = anotherOptional {
    print("解包后的值: \(unwrapped)") // 输出: 解包后的值: Hello
}

需要注意的是，可选常量一旦被赋值为非 nil 值，就不能再修改为其他值或 nil。

9. 常量在集合中的应用

Swift 中的数组、字典和集合都可以声明为常量。声明为常量的集合，其引用不可改变，但集合内部的元素是否可变取决于集合本身的类型。

9.1 常量数组

// 常量数组
let fruits = ["苹果", "香蕉", "橙子"]
print(fruits[0]) // 输出: 苹果

// 以下操作会报错，因为 fruits 是常量
// fruits.append("葡萄") // 编译错误: Cannot use mutating member on immutable value

// 但可以读取和遍历
for fruit in fruits {
    print(fruit)
}

9.2 常量字典

// 常量字典
let httpStatusCodes = [
    200: "成功",
    404: "未找到",
    500: "服务器错误"
]

print(httpStatusCodes[200] ?? "未知状态") // 输出: 成功

// 以下操作会报错
// httpStatusCodes[301] = "永久重定向" // 编译错误

9.3 常量集合

// 常量集合
let primeNumbers: Set<Int> = [2, 3, 5, 7, 11]
print(primeNumbers.contains(5)) // 输出: true

// 以下操作会报错
// primeNumbers.insert(13) // 编译错误

10. 常量与结构体、类

常量与结构体、类的交互方式有所不同。结构体是值类型，常量结构体的属性不可修改；类是引用类型，常量引用指向的对象属性仍然可以修改。

10.1 常量结构体

struct Point {
    var x: Double
    var y: Double
}

// 常量结构体
let origin = Point(x: 0.0, y: 0.0)
print("原点坐标: (\(origin.x), \(origin.y))")

// 以下操作会报错，因为 origin 是常量
// origin.x = 10.0 // 编译错误: Cannot assign to property: 'origin' is a 'let' constant

10.2 常量类实例

class Counter {
    var count = 0
}

// 常量引用
let counter = Counter()
counter.count = 10 // 允许修改，因为 count 是可变属性
print(counter.count) // 输出: 10

// 以下操作会报错，因为 counter 是常量引用
// counter = Counter() // 编译错误: Cannot assign to value: 'counter' is a 'let' constant

这个区别非常重要：常量类实例的引用不可改变，但通过该引用修改对象的属性是允许的。

11. 常量的实际应用场景

在实际开发中，合理使用常量可以提升代码质量。以下是一些常见的应用场景：

11.1 配置参数

struct AppSettings {
    static let apiTimeout: TimeInterval = 30.0
    static let maxUploadSize = 10 * 1024 * 1024 // 10MB
    static let defaultLocale = "zh_CN"
}

// 使用配置参数
print("API 超时时间: \(AppSettings.apiTimeout) 秒")
print("最大上传大小: \(AppSettings.maxUploadSize) 字节")

11.2 枚举关联值

enum NetworkError: Error {
    case timeout
    case serverError(code: Int)
    case invalidResponse
}

// 使用常量定义错误码
let serverErrorCode = 500
let error = NetworkError.serverError(code: serverErrorCode)

switch error {
case .serverError(let code):
    print("服务器错误，错误码: \(code)")
default:
    print("其他错误")
}

11.3 数学常量

// 定义数学常量
let goldenRatio = 1.6180339887
let eulerNumber = 2.7182818284

func calculateCompoundInterest(principal: Double, rate: Double, years: Int) -> Double {
    let base = 1 + rate
    let exponent = Double(years)
    return principal * pow(base, exponent)
}

let result = calculateCompoundInterest(principal: 1000, rate: 0.05, years: 10)
print("复利计算结果: \(result)")

12. 常量的性能优势

使用常量不仅有助于代码安全，还能带来性能上的优势。编译器可以对常量进行更积极的优化，例如内联展开、常量折叠等，从而减少运行时开销。

// 编译器可以在编译期计算常量表达式
let taxRate = 0.08
let price = 100.0
let tax = price * taxRate // 编译器可能直接计算为 8.0
let totalPrice = price + tax

print("税额: \(tax)")
print("总价: \(totalPrice)")

在热路径（如循环内部）使用常量，可以避免重复计算，提升程序运行效率。

13. 常见错误与注意事项

在使用常量时，开发者常会遇到一些典型错误。了解这些错误有助于避免踩坑。

13.1 尝试修改常量

let fixedValue = 10
// fixedValue = 20 // 编译错误: Cannot assign to value: 'fixedValue' is a 'let' constant

13.2 未初始化就使用

// 常量必须在声明时初始化
// let uninitialized: Int
// print(uninitialized) // 编译错误: Constant 'uninitialized' used before being initialized

13.3 混淆常量和变量

// 错误示例：本应使用常量却使用了变量
var maxAttempts = 3
maxAttempts = 3 // 冗余赋值，应使用 let

// 正确做法
let maxAttemptsCorrect = 3

14. 总结

Swift 常量是编写安全、高效代码的重要工具。通过 let 关键字声明常量，可以确保数据在初始化后不被修改，从而减少潜在的错误。本文从基本语法、类型推断、命名规范、作用域、与集合和类型的交互等多个角度，结合丰富的代码实例，全面介绍了 Swift 常量的使用方法和注意事项。在实际开发中，建议遵循「能使用常量就尽量使用常量」的原则，仅在确实需要修改值时才使用变量，这样可以让代码更加健壮、可读性更高。