Swift中属性（Property）的分类

Swift中属性（Property）的分类

在Swift的学习过程中，我发现理解属性，对后续学习类（Class）、枚举（Enumeration）和协议（Protocol）很有帮助，现在总结一下Swift中属性的分类，主要分为四大类：

1. 存储实例属性（Stored Instance Property）：存储在实例的内存中的属性，只有一份

2. 计算实例属性（Computed Instance Property）：不占用系统内存，调用的时候才计算得出的实例属性，类似实例的方法

3. 存储类型属性（Stored Type Property）：整个程序运行过程中就只有一份内存，类似全局变量或常量

4. 计算类型属性（Computed Type Property)：不占用系统内存，调用的时候才计算得出的属性，类似全局函数

下面分别详细的总结一下：

存储实例属性：

• 类（class）和结构体（struct）都可以定义存储属性，可以是变量var或者常数let，而枚举（enum）内不能定义存储实例属性：

enum Animal {
    case dog
    var cat = "Cat"  // Enums must not contain stored properties
}

• 创建类或者结构体时，所有存储实例属性必须初始化（设置初始值或者在init中赋值），否则编译不过：

class WrongAnimal {
    let legs: Int
    let eyes: Int
}  // Class 'WrongAnimal' has no initializers

// 所有存储实例属性必须初始化：
class Animal {
    let legs: Int = 4
    let eyes: Int
    init(eyes: Int ) {
        self.eyes = eyes
    }
}
var animal = Animal(eyes: 2)

• extension中不能定义存储实例属性：

extension Animal {
    var ears: Int = 4  // Extensions must not contain stored properties
}

计算实例属性：

• 类、结构体、枚举都可以定义计算实例属性
• 计算属性不存储值，不用初始化，但至少需要提供一个getter（get)取值，setter（set)赋值是可选的，比如：

struct Point {
    var x: Double
    var y: Double
    var distanceToOrigin: Double {
        get {
            return sqrt(x * x + y * y)
        }
    }
}
let point = Point(x: 3, y: 4)
point.distanceToOrigin  // 5

• 定义计算属性只能使用var, 不能使用let
• 如果get中只有一条return语句，则可以省掉return和get关键字，比如：

struct Point {
    var x: Double
    var y: Double
    var distanceToOrigin: Double {
        sqrt(x * x + y * y)
    }
}

• entension可以定义计算属性:

extension Point {
    var z: Double { 1.0 }
}

• 可以在协议（protocol）的extension中定义计算实例属性，这样相当于实现了协议中的一个成员，比如：

protocol Game {
    var win: Int { get set }
    var lose: Int { get set }
}

extension Game {
    var winRate: Double {
        Double(win) / (Double(win) + Double(lose))
    }
}

struct FootballGame: Game {
    var win: Int
    var lose: Int
}
let footballGame = FootballGame(win: 8, lose: 2)
footballGame.winRate  // 0.8

• 枚举的rawValue的本质就是实例计算属性, 而且是只读的计算属性：

enum Color: Int {
    case red = 1
    case blue = 2
    case yellow = 3
}
Color.blue.rawValue  // 2
Color.yellow.rawValue = 4  // Cannot assign to property: 'rawValue' is immutable

• 我们可以在enum重新定义rawValue计算属性：

enum Color: Int {
    case red = 1
    case blue = 2
    case yellow = 3
    
    var rawValue: Int {
        switch self {
        case .red:
            return 10
        case .blue:
            return 20
        case .yellow:
            return 30
        }
    }
}
Color.blue.rawValue  // 20

存储类型类型属性：

• 类、结构体、枚举中使用static定义

struct Storage {
    static let books = 10
    static var money = 20
}
Store.books  // 10
Store.money = 30

• 存储类型类型属性必须有初始值，不用使用init初始化
• 存储类型类型只会在第一次使用的时候初始化
• 存储类型属性不能在子类中被重写

class Storage {
    static let books = 10
    static var money = 20
}
class LargeStorage: Storage {
    static let books = 20  // Cannot override with a stored property 'books'
}

• extension中可以定义储存类型属性，我们可以用这种方法，扩展UIKit里常用的类，比如UIColor、UIFont等：

extension UIColor {
    static let myColor = UIColor.init(red: 0.5, green: 0.5, blue: 0.5, alpha: 0.5)
}
UIColor.myColor

计算类型类型属性：

• 类、结构体、枚举中使用static定义计算类型属性，类中还可以使用class关键字定义

	class Storage {
    static let books = 10
    class var money: Double {
        20
    }
}

• 同计算实例属性一样，定义计算属性只能使用var, 不能使用let
• 使用class关键字时，计算类型属性可以在子类中被重写：

class LargeStorage: Storage {
    override class var money: Double {
        30
    }
}

• extension中可以定义计算类型属性

总结

Swift中的属性主要可以分为四大类：存储实例属性，计算实例属性，存储类型属性，计算类型属性。

进一步总结，如果按内存存储方式分类，可以分为两大类：存储属性（存储在系统内存中变量或者常量）和计算属性（不占用内存，类似函数），如果按属性是属于实例还是类，可以分为：实例属性（属于实例的属性）和类型属性（属于类的属性，用static或者class修饰）。

理解的属性的分类，我们可以大概推出某类属性的适用场景和规则，比如存储实例属性，因为要存储在实例的内存中，所以实例初始化的时候必须初始化全部的存储属性（optional类型除外），这也解释了为什么extension中为什么不能添加存储实例属性，因为如果这样做了，那么这个属性就必须存在于实例的内存中，那之前所有已经初始化的实例就必须全部修改，几乎不可能实现，所以extension中只能添加计算属性或者存储类型属性。

理解分类后，以后看到一个属性，大概知道这是什么类型的属性，从而理解这个属性设计者的意图，加快理解代码。

其实属性还有很多内容，比如属性观察器（property observers），对应关键字willSet和didSet，还有延迟属性（lazy properties)，理解属性分类后再去学习这些内容会容易很多。