Swift 属性（保姆级教程）

Swift 属性：理解类与结构体的核心组成

在 Swift 编程语言中，属性是类（class）和结构体（struct）用来存储值的核心机制。它就像一个“小抽屉”，每个对象都有自己的抽屉，里面存放着与它相关的数据。无论是用户信息、商品价格，还是游戏角色的生命值，都通过属性来表达。掌握好 Swift 属性，就等于掌握了构建复杂对象的基石。

初学者常误以为属性只是“变量”，但实际上它在 Swift 中拥有更丰富的语义和控制能力。我们不仅可以在属性中存值，还能在读取或设置值时加入逻辑判断、自动计算，甚至触发外部行为。这使得 Swift 属性不仅仅是数据容器，更是一种“智能数据单元”。

本文将带你从零开始，逐步理解 Swift 属性的类型、使用方式、内存管理机制以及实际开发中的最佳实践。无论你是刚接触 Swift 的新人，还是已有一定经验的开发者，都能在这里找到提升代码质量的关键点。

属性的基本语法与类型

在 Swift 中，属性主要分为两类：存储属性（Stored Properties）和计算属性（Computed Properties）。它们看似相似，实则用途不同。

存储属性用于保存具体值，是属性最常见、最直接的形式。例如，一个 Person 类可以有 name 和 age 两个存储属性：

struct Person {
    // 存储属性：用于直接保存值
    var name: String
    var age: Int
}

这里，name 和 age 都是存储属性。当创建一个 Person 实例时，系统会为它们分配内存空间来存放实际数据。

而计算属性则不直接保存值，而是通过计算方式动态返回结果。比如我们想获取一个人的年龄等级（少年、青年、中年等），就可以用计算属性来实现：

struct Person {
    var name: String
    var age: Int
    
    // 计算属性：不保存值，而是通过计算返回结果
    var ageCategory: String {
        // 根据年龄返回不同分类
        if age < 13 {
            return "少年"
        } else if age < 20 {
            return "青年"
        } else if age < 45 {
            return "中年"
        } else {
            return "老年"
        }
    }
}

注意：计算属性必须使用 var 声明，因为它的值是“可变”的（每次调用都会重新计算）。若用 let 声明，编译器会报错。

存储属性是“静态”的，它存的是“是什么”；计算属性是“动态”的，它回答的是“是什么样子”。

属性的修饰符与访问控制

Swift 属性支持多种修饰符，用于控制其行为和访问权限。这些修饰符让代码更加安全、可维护。

首先，private、internal、public 等访问控制修饰符决定了属性是否能被外部访问：

class BankAccount {
    // 私有属性：只能在类内部访问
    private var balance: Double = 0.0
    
    // 内部属性：同一模块内可访问
    internal var accountNumber: String
    
    // 公共属性：所有模块都可访问
    public var ownerName: String
    
    init(accountNumber: String, ownerName: String) {
        self.accountNumber = accountNumber
        self.ownerName = ownerName
    }
}

这里，balance 是私有的，防止外部随意修改账户余额。而 ownerName 是公开的，方便其他代码读取。

其次是 lazy 修饰符，用于延迟初始化。它适用于那些创建成本高、但并非每次都会用到的属性：

class DataProcessor {
    // 延迟加载：只有第一次访问时才创建
    lazy var largeData: [Int] = {
        print("正在加载大数据...")
        return (1...1000000).map { $0 * 2 }
    }()
}

lazy 的好处是：如果程序永远没用到 largeData，那它根本不会被创建，节省了内存和启动时间。这就像你家里的冰箱，只有打开门准备拿东西时，才启动制冷系统。

还有 static 和 class 修饰符，用于定义类型属性（即类级别的属性），而不是实例属性：

struct Counter {
    // 类型属性：所有实例共享
    static var totalInstances = 0
    
    // 实例属性：每个实例独立
    var count = 0
    
    init() {
        Counter.totalInstances += 1
    }
}

每次创建 Counter 实例时，totalInstances 都会加一。它不依赖于某个具体对象，而是属于“类”本身。

属性观察器：监听值的变化

在实际开发中，我们常常需要在属性值发生变化时执行某些操作。比如，当用户年龄改变时，要更新其登录权限；或者当价格变动时，自动刷新界面。Swift 提供了 willSet 和 didSet 两个属性观察器，专门用于监听属性变化。

class User {
    var age: Int = 0 {
        // willSet：在新值设置前调用
        willSet {
            print("即将设置年龄为：\(newValue)")
        }
        
        // didSet：在新值设置后调用
        didSet {
            if age > 18 {
                print("已成年，可以访问成人内容")
            } else if age < 13 {
                print("未成年人，建议家长陪同")
            }
        }
    }
}

当你设置 user.age = 25 时，控制台会输出：

即将设置年龄为：25
已成年，可以访问成人内容

newValue 是即将被设置的新值，oldValue 是旧值。这两个参数是自动提供的，无需手动传入。

属性观察器非常适用于：

• 数据校验（如检查年龄是否为负数）
• 自动更新 UI（如刷新标签）
• 日志记录（如记录配置变更）

但要注意：willSet 和 didSet 不能用于 let 常量属性，因为常量的值在初始化后就不能改变。

属性与内存管理：引用 vs 值类型

在 Swift 中，struct 和 class 的区别直接影响属性的行为。理解这一点，对编写高效、安全的代码至关重要。

结构体（struct）是值类型，意味着当你复制一个结构体实例时，会创建一份完整副本：

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

var p1 = Point(x: 1.0, y: 2.0)
var p2 = p1  // 创建副本
p2.x = 10.0

print(p1.x) // 输出 1.0，p1 没有变化
print(p2.x) // 输出 10.0

每个结构体都有自己的属性副本，互不影响。这就像你复制一份 Word 文档，原文件不会被修改。

而类（class）是引用类型，复制的是“指针”：

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

var p1 = Person(name: "Alice")
var p2 = p1  // p2 指向同一个对象
p2.name = "Bob"

print(p1.name) // 输出 Bob，p1 的 name 也被改变了
print(p2.name) // 输出 Bob

这里，p1 和 p2 指向同一块内存。修改 p2.name，p1.name 也会同步变化。

因此，在设计属性时要明确：你是要共享数据（用 class），还是隔离数据（用 struct）。这关系到代码的可预测性和内存占用。

实际应用：构建一个完整的用户信息管理器

让我们通过一个真实案例，综合运用前面讲解的所有概念。我们将创建一个 UserProfile 结构体，用于管理用户信息。

struct UserProfile {
    // 存储属性：用户基本信息
    var username: String
    var email: String
    private var _password: String  // 私有属性，防止外部访问
    
    // 计算属性：根据用户名生成昵称
    var nickname: String {
        return username.count > 0 ? "用户\(username.prefix(3))" : "匿名用户"
    }
    
    // 延迟加载：只在需要时才生成日志
    lazy var loginLog: [String] = {
        print("初始化登录日志...")
        return []
    }()
    
    // 属性观察器：监控密码修改
    var password: String {
        get {
            return _password
        }
        set {
            if newValue.count < 6 {
                print("警告：密码长度应至少 6 位")
            } else {
                print("密码已更新")
            }
            _password = newValue
        }
    }
    
    // 类型属性：记录所有用户数量
    static var totalUsers: Int = 0
    
    // 构造器：初始化时自动计数
    init(username: String, email: String, password: String) {
        self.username = username
        self.email = email
        self.password = password
        UserProfile.totalUsers += 1
    }
}

使用示例：

let user = UserProfile(username: "zhangsan", email: "zhang@163.com", password: "12345")
print(user.nickname)  // 输出：用户zha

user.password = "123456"  // 输出：密码已更新
user.password = "123"    // 输出：警告：密码长度应至少 6 位

这个例子涵盖了：

• 存储属性与计算属性的结合
• 私有属性的封装
• 延迟加载的应用
• 属性观察器的监控逻辑
• 类型属性的全局计数
• 访问控制与安全设计

它展示了如何用 Swift 属性构建一个健壮、可维护的业务模型。

总结：掌握 Swift 属性，提升代码质量

Swift 属性远不止是“变量”的代称。它是构建对象状态的核心工具，融合了数据存储、逻辑控制、访问安全和内存管理等多重能力。从简单的存储属性，到复杂的计算属性与观察器，每一种用法都在为代码的健壮性服务。

作为开发者，我们不仅要会写属性，更要懂得“为什么这样写”。是选择 struct 还是 class？是使用 lazy 还是立即初始化？是公开属性还是私有封装？每一个决定，都影响着程序的性能、可读性和可维护性。

当你能熟练运用 Swift 属性，就能写出更清晰、更安全、更高效的代码。它不仅是语言特性，更是一种编程思维的体现。希望本文能成为你深入理解 Swift 属性的起点，助你在开发路上走得更稳、更远。