• 計算屬性可以用于類、結構體和枚舉，
• 存儲屬性只能用于類和結構體。

枚舉只能有計算屬性

• 屬性觀察器可以添加到自己定義的存儲屬性上，也可以添加到從父類繼承的屬性上。

• 屬性觀察者是對存儲屬性而言的，類和結構體都可以用，但枚舉不行。對于類來說，屬性觀察者可以觀察基類成員。
• 支持多用屬性觀察者，相比于KVO難用的API，這個方便多了

• 屬性也可以直接作用于類型本身，這種屬性稱為類型屬性。

靜態屬性或者類屬性

存儲屬性（Stored Properties）

• 存儲屬性可以是變量存儲屬性（用關鍵字 var 定義），也可以是常量存儲屬性（用關鍵字 let 定義）。

默認都定義為let，實在有必要的才用var，好習慣一開始就要養成

• 可以在定義存儲屬性的時候指定默認值，也可以在構造過程中設置或修改存儲屬性的值，甚至修改常量存儲屬性的值。

• ViewModel推薦給默認值，用普通變量。就算不顯示，也先給一個“”
• Model推薦不設默認值，用可選類型，模擬現實中收不到網絡數據的情況

• 如果創建了一個結構體的實例并將其賦值給一個常量，則無法修改該實例的任何屬性，即使有屬性被聲明為變量也不行。

• 這種行為是由于結構體（struct）屬于值類型。當值類型的實例被聲明為常量的時候，它的所有屬性也就成了常量。
• 屬于引用類型的類（class）則不一樣。把一個引用類型的實例賦給一個常量后，仍然可以修改該實例的變量屬性。

• 延遲存儲屬性是指當第一次被調用的時候才會計算其初始值的屬性。

• 在屬性聲明前使用 lazy 來標示一個延遲存儲屬性。
  延遲屬性很有用，當屬性的值依賴于在實例的構造過程結束后才會知道影響值的外部因素時，或者當獲得屬性的初始值需要復雜或大量計算時，可以只在需要的時候計算它。
• 必須將延遲存儲屬性聲明成變量（使用 var 關鍵字），因為屬性的初始值可能在實例構造完成之后才會得到。而常量屬性在構造過程完成之前必須要有初始值，因此無法聲明成延遲屬性。
• 如果一個被標記為 lazy 的屬性在沒有初始化時就同時被多個線程訪問，則無法保證該屬性只會被初始化一次。也就是說lazy屬性不是線程安全的，在多線程條件下要注意

class DataImporter {
    /*
    DataImporter 是一個負責將外部文件中的數據導入的類。
    這個類的初始化會消耗不少時間。
    */
    var fileName = "data.txt"
    // 這里會提供數據導入功能
}

class DataManager {
    lazy var importer = DataImporter()
    var data = [String]()
    // 這里會提供數據管理功能
}

let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")
// DataImporter 實例的 importer 屬性還沒有被創建

print(manager.importer.fileName)
// DataImporter 實例的 importer 屬性現在被創建了
// 輸出 "data.txt”

• Swift 中的屬性沒有對應的實例變量，屬性的后端存儲也無法直接訪問。

Object-C中屬性其實是get、set函數，_屬性名 是其背后的成員變量。一般情況，屬性名用于外部訪問，內部用下劃線內部變量。在Swift中，就沒有了到底用哪個的糾結了。

計算屬性（Computed Properties）

• 計算屬性不直接存儲值，而是提供一個 getter 和一個可選的 setter，來間接獲取和設置其他屬性或變量的值。
• 如果計算屬性的 setter 沒有定義表示新值的參數名，則可以使用默認名稱 newValue。
• 只有 getter 沒有 setter 的計算屬性就是只讀計算屬性。只讀計算屬性總是返回一個值，可以通過點運算符訪問，但不能設置新的值。
• 必須使用 var 關鍵字定義計算屬性，包括只讀計算屬性，因為它們的值不是固定的。
• 只讀計算屬性的聲明可以去掉 get 關鍵字和花括號

支持多用只讀計算屬性，多用這種方便寫法

struct Point {
    var x = 0.0, y = 0.0
}
struct Size {
    var width = 0.0, height = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set(newCenter) {
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
    }
}
var square = Rect(origin: Point(x: 0.0, y: 0.0),
    size: Size(width: 10.0, height: 10.0))
let initialSquareCenter = square.center
square.center = Point(x: 15.0, y: 15.0)
print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
// 輸出 "square.origin is now at (10.0, 10.0)”

struct AlternativeRect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set {
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.y - (size.height / 2)
        }
    }
}

struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
        return width * height * depth
    }
}
let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
// 輸出 "the volume of fourByFiveByTwo is 40.0"

屬性觀察器（Property Observers）

• 屬性觀察器監控和響應屬性值的變化，每次屬性被設置值的時候都會調用屬性觀察器，即使新值和當前值相同的時候也不例外。

• 可以為除了延遲存儲屬性之外的其他存儲屬性添加屬性觀察器。

lazy 修飾的屬性不能添加屬性觀察器

• 可以通過重寫屬性的方式為繼承的屬性（包括存儲屬性和計算屬性）添加屬性觀察器。

• 不必為非重寫的計算屬性添加屬性觀察器，因為可以通過它的getter, setter 直接監控和響應值的變化。

• willSet 在新的值被設置之前調用

willSet 觀察器會將新的屬性值作為常量參數傳入，在 willSet 的實現代碼中可以為這個參數指定一個名稱，如果不指定則參數仍然可用，這時使用默認名稱 newValue 表示。

• didSet 在新的值被設置之后立即調用

didSet 觀察器會將舊的屬性值作為參數傳入，可以為該參數命名或者使用默認參數名 oldValue。如果在 didSet 方法中再次對該屬性賦值，那么新值會覆蓋舊的值。

• 如果將屬性通過 in-out 方式傳入函數，willSet 和 didSet 也會調用。這是因為 in-out 參數采用了拷入拷出模式：即在函數內部使用的是參數的 copy，函數結束后，又對參數重新賦值。

• 父類的屬性在子類的構造器中被賦值時，它在父類中的 willSet 和 didSet 觀察器會被調用，隨后才會調用子類的觀察器。在父類初始化方法調用之前，子類給屬性賦值時，觀察器不會被調用。

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("About to set totalSteps to \(newTotalSteps)")
        }
        didSet {
            if totalSteps > oldValue  {
                print("Added \(totalSteps - oldValue) steps")
            }
        }
    }
}
let stepCounter = StepCounter()
stepCounter.totalSteps = 200
// About to set totalSteps to 200
// Added 200 steps
stepCounter.totalSteps = 360
// About to set totalSteps to 360
// Added 160 steps
stepCounter.totalSteps = 896
// About to set totalSteps to 896
// Added 536 steps

全局變量和局部變量（Global and Local Variables）

• 計算屬性和屬性觀察器所描述的功能也可以用于全局變量和局部變量。
• 在全局或局部范圍都可以定義計算型變量和為存儲型變量定義觀察器。計算型變量跟計算屬性一樣，返回一個計算結果而不是存儲值，聲明格式也完全一樣。
• 全局的常量或變量都是延遲計算的，跟延遲存儲屬性相似，不同的地方在于，全局的常量或變量不需要標記lazy修飾符。
• 局部范圍的常量或變量從不延遲計算。

類型屬性（Type Properties）

• 類型屬性用于定義某個類型所有實例共享的數據，比如所有實例都能用的一個常量（就像 C 語言中的靜態常量），或者所有實例都能訪問的一個變量（就像 C 語言中的靜態變量）。
• 存儲型類型屬性可以是變量或常量，計算型類型屬性只能定義成變量屬性。
• 跟實例的存儲型屬性不同，必須給存儲型類型屬性指定默認值，因為類型本身沒有構造器，也就無法在初始化過程中使用構造器給類型屬性賦值。
• 存儲型類型屬性是延遲初始化的，它們只有在第一次被訪問的時候才會被初始化。即使它們被多個線程同時訪問，系統也保證只會對其進行一次初始化，并且不需要對其使用 lazy 修飾符。
• 類型屬性是作為類型定義的一部分寫在類型最外層的花括號內，因此它的作用范圍也就在類型支持的范圍內。
• 使用關鍵字 static 來定義類型屬性。
• 在為類定義計算型類型屬性時，可以改用關鍵字 class 來支持子類對父類的實現進行重寫。
• 跟實例屬性一樣，類型屬性也是通過點運算符來訪問。但是，類型屬性是通過類型本身來訪問，而不是通過實例。

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 1
    }
}
enum SomeEnumeration {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 6
    }
}
class SomeClass {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 27
    }
    class var overrideableComputedTypeProperty: Int {
        return 107    // 類，計算屬性，重寫
    }
}

print(SomeStructure.storedTypeProperty)
// 輸出 "Some value."
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
// 輸出 "Another value.”
print(SomeEnumeration.computedTypeProperty)
// 輸出 "6"
print(SomeClass.computedTypeProperty)
// 輸出 "27"

struct AudioChannel {
    static let thresholdLevel = 10
    static var maxInputLevelForAllChannels = 0
    var currentLevel: Int = 0 {
        didSet {
            if currentLevel > AudioChannel.thresholdLevel {
                // 將當前音量限制在閥值之內
                currentLevel = AudioChannel.thresholdLevel
            }
            if currentLevel > AudioChannel.maxInputLevelForAllChannels {
                // 存儲當前音量作為新的最大輸入音量
                AudioChannel.maxInputLevelForAllChannels = currentLevel
            }
        }
    }
}
var leftChannel = AudioChannel()
var rightChannel = AudioChannel()

leftChannel.currentLevel = 7
print(leftChannel.currentLevel)
// 輸出 "7"
print(AudioChannel.maxInputLevelForAllChannels)
// 輸出 "7"

rightChannel.currentLevel = 11
print(rightChannel.currentLevel)
// 輸出 "10"
print(AudioChannel.maxInputLevelForAllChannels)
// 輸出 "10"

• 類變量用static修飾，在一個struct內，用上了let或者var，這種方式可以替代define
• 孤零零的全局變量盡量不要用，放在某個struct內進行歸類。實在想用，也可以包裝成一個單例再用。雖然不需要寫external，用起來方便，但全局變量的副作用一點也沒有被限制。
• 計算屬性是getter，setter；屬性觀察器是willSet和didSet；newValue，oldValue是隱含變量，方便使用；屬性觀察器需要給默認值，初始化（如果是存儲屬性）；計算屬性本質上像函數，不需要初始化，不需要默認值。這兩者在代碼結構上有點類似，需要區分清楚
• lazy 標記的屬性要按普通的屬性一樣初始化。只不過其真正執行初始化代碼在調用的時候。
• 屬性觀察器可以替代部分KVO的功能，但是用起來比KVO方便多了，鼓勵多用。
• 類的類屬性，也統一用static吧，跟struct一樣，好記又方便，基本就可以了。用class，計算屬性，類才行，還要重寫基類屬性。這么復雜，有必要用嗎？