屬性 - Properties

屬性 (Properties)

屬性將值跟特定的類、結(jié)構(gòu)或枚舉關(guān)聯(lián)。存儲屬性存儲常量或變量作為實例的一部分，計算屬性計算（而不是存儲）一個值。計算屬性可以用于類、結(jié)構(gòu)體和枚舉里，存儲屬性只能用于類和結(jié)構(gòu)體。

存儲屬性和計算屬性通常用于特定類型的實例，但是，屬性也可以直接用于類型本身，這種屬性稱為類型屬性。

另外，還可以定義屬性觀察器來監(jiān)控屬性值的變化，以此來觸發(fā)一個自定義的操作。屬性觀察器可以添加到自己寫的存儲屬性上，也可以添加到從父類繼承的屬性上。

存儲屬性

簡單來說，一個存儲屬性就是存儲在特定類或結(jié)構(gòu)體的實例里的一個常量或變量，存儲屬性可以是變量存儲屬性（用關(guān)鍵字var定義），也可以是常量存儲屬性（用關(guān)鍵字let定義）。

可以在定義存儲屬性的時候指定默認(rèn)值，請參考構(gòu)造過程一章的默認(rèn)屬性值一節(jié)。也可以在構(gòu)造過程中設(shè)置或修改存儲屬性的值，甚至修改常量存儲屬性的值，請參考構(gòu)造過程一章的構(gòu)造過程中常量屬性的修改一節(jié)。

下面的例子定義了一個名為FixedLengthRange的結(jié)構(gòu)體，它描述了一個在創(chuàng)建后無法修改值域?qū)挾鹊膮^(qū)間：

    struct FixedLengthRange {
        var firstValue: Int
        let length: Int
    }
    var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
    // 該區(qū)間表示整數(shù)0，1，2
    rangeOfThreeItems.firstValue = 6
    // 該區(qū)間現(xiàn)在表示整數(shù)6，7，8

FixedLengthRange的實例包含一個名為firstValue的變量存儲屬性和一個名為length的常量存儲屬性。在上面的例子中，length在創(chuàng)建實例的時候被賦值，因為它是一個常量存儲屬性，所以之后無法修改它的值。

常量和存儲屬性

如果創(chuàng)建了一個結(jié)構(gòu)體的實例并賦值給一個常量，則無法修改實例的任何屬性，即使定義了變量存儲屬性：

    let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
    // 該區(qū)間表示整數(shù)0，1，2，3
    rangeOfFourItems.firstValue = 6
    // 盡管 firstValue 是個變量屬性，這里還是會報錯

因為rangeOfFourItems聲明成了常量（用let關(guān)鍵字），即使firstValue是一個變量屬性，也無法再修改它了。

這種行為是由于結(jié)構(gòu)體（struct）屬于值類型。當(dāng)值類型的實例被聲明為常量的時候，它的所有屬性也就成了常量。

屬于引用類型的類（class）則不一樣，把一個引用類型的實例賦給一個常量后，仍然可以修改實例的變量屬性。

延遲存儲屬性

延遲存儲屬性是指當(dāng)?shù)谝淮伪徽{(diào)用的時候才會計算其初始值的屬性。在屬性聲明前使用lazy來標(biāo)示一個延遲存儲屬性。

注意：
必須將延遲存儲屬性聲明成變量（使用var關(guān)鍵字），因為屬性的值在實例構(gòu)造完成之前可能無法得到。而常量屬性在構(gòu)造過程完成之前必須要有初始值，因此無法聲明成延遲屬性。

延遲屬性很有用，當(dāng)屬性的值依賴于在實例的構(gòu)造過程結(jié)束前無法知道具體值的外部因素時，或者當(dāng)屬性的值需要復(fù)雜或大量計算時，可以只在需要的時候來計算它。

下面的例子使用了延遲存儲屬性來避免復(fù)雜類的不必要的初始化。例子中定義了DataImporter和DataManager兩個類，下面是部分代碼：

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

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

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

DataManager類包含一個名為data的存儲屬性，初始值是一個空的字符串（String）數(shù)組。雖然沒有寫出全部代碼，DataManager類的目的是管理和提供對這個字符串?dāng)?shù)組的訪問。

DataManager的一個功能是從文件導(dǎo)入數(shù)據(jù)，該功能由DataImporter類提供，DataImporter需要消耗不少時間完成初始化：因為它的實例在初始化時可能要打開文件，還要讀取文件內(nèi)容到內(nèi)存。

DataManager也可能不從文件中導(dǎo)入數(shù)據(jù)。所以當(dāng)DataManager的實例被創(chuàng)建時，沒必要創(chuàng)建一個DataImporter的實例，更明智的是當(dāng)用到DataImporter的時候才去創(chuàng)建它。

由于使用了lazy，importer屬性只有在第一次被訪問的時候才被創(chuàng)建。比如訪問它的屬性fileName時：

    println(manager.importer.fileName)
    // DataImporter 實例的 importer 屬性現(xiàn)在被創(chuàng)建了
    // 輸出 "data.txt”

存儲屬性和實例變量

如果您有過 Objective-C 經(jīng)驗，應(yīng)該知道Objective-C為類實例存儲值和引用提供兩種方法。對于屬性來說，也可以使用實例變量作為屬性值的后端存儲。

Swift 編程語言中把這些理論統(tǒng)一用屬性來實現(xiàn)。Swift 中的屬性沒有對應(yīng)的實例變量，屬性的后端存儲也無法直接訪問。這就避免了不同場景下訪問方式的困擾，同時也將屬性的定義簡化成一個語句。一個類型中屬性的全部信息——包括命名、類型和內(nèi)存管理特征——都在唯一一個地方（類型定義中）定義。

計算屬性

除存儲屬性外，類、結(jié)構(gòu)體和枚舉可以定義計算屬性，計算屬性不直接存儲值，而是提供一個 getter 來獲取值，一個可選的 setter 來間接設(shè)置其他屬性或變量的值。

    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)
    println("square.origin is now at (\(square.origin.x), \(square.origin.y))")
    // 輸出 "square.origin is now at (10.0, 10.0)”

這個例子定義了 3 個幾何形狀的結(jié)構(gòu)體：

• Point封裝了一個(x, y)的坐標(biāo)
• Size封裝了一個width和height
• Rect表示一個有原點和尺寸的矩形

Rect也提供了一個名為center的計算屬性。一個矩形的中心點可以從原點和尺寸來算出，所以不需要將它以顯式聲明的Point來保存。Rect的計算屬性center提供了自定義的 getter 和 setter 來獲取和設(shè)置矩形的中心點，就像它有一個存儲屬性一樣。

例子中接下來創(chuàng)建了一個名為square的Rect實例，初始值原點是(0, 0)，寬度高度都是10。如圖所示藍(lán)色正方形。

square的center屬性可以通過點運算符（square.center）來訪問，這會調(diào)用 getter 來獲取屬性的值。跟直接返回已經(jīng)存在的值不同，getter 實際上通過計算然后返回一個新的Point來表示square的中心點。如代碼所示，它正確返回了中心點(5, 5)。

center屬性之后被設(shè)置了一個新的值(15, 15)，表示向右上方移動正方形到如圖所示橙色正方形的位置。設(shè)置屬性center的值會調(diào)用 setter 來修改屬性origin的x和y的值，從而實現(xiàn)移動正方形到新的位置。

便捷 setter 聲明

如果計算屬性的 setter 沒有定義表示新值的參數(shù)名，則可以使用默認(rèn)名稱newValue。下面是使用了便捷 setter 聲明的Rect結(jié)構(gòu)體代碼：

    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)
        }
        }
    }

只讀計算屬性

只有 getter 沒有 setter 的計算屬性就是只讀計算屬性。只讀計算屬性總是返回一個值，可以通過點運算符訪問，但不能設(shè)置新的值。

注意：

必須使用var關(guān)鍵字定義計算屬性，包括只讀計算屬性，因為它們的值不是固定的。let關(guān)鍵字只用來聲明常量屬性，表示初始化后再也無法修改的值。

只讀計算屬性的聲明可以去掉get關(guān)鍵字和花括號：

    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)
    println("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
    // 輸出 "the volume of fourByFiveByTwo is 40.0"

這個例子定義了一個名為Cuboid的結(jié)構(gòu)體，表示三維空間的立方體，包含width、height和depth屬性，還有一個名為volume的只讀計算屬性用來返回立方體的體積。設(shè)置volume的值毫無意義，因為通過width、height和depth就能算出volume。然而，Cuboid提供一個只讀計算屬性來讓外部用戶直接獲取體積是很有用的。

屬性觀察器

屬性觀察器監(jiān)控和響應(yīng)屬性值的變化，每次屬性被設(shè)置值的時候都會調(diào)用屬性觀察器，甚至新的值和現(xiàn)在的值相同的時候也不例外。

可以為除了延遲存儲屬性之外的其他存儲屬性添加屬性觀察器，也可以通過重載屬性的方式為繼承的屬性（包括存儲屬性和計算屬性）添加屬性觀察器。屬性重載請參考繼承一章的重載。

注意：
不需要為無法重載的計算屬性添加屬性觀察器，因為可以通過 setter 直接監(jiān)控和響應(yīng)值的變化。

可以為屬性添加如下的一個或全部觀察器：

• willSet在設(shè)置新的值之前調(diào)用
• didSet在新的值被設(shè)置之后立即調(diào)用

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

類似地，didSet觀察器會將舊的屬性值作為參數(shù)傳入，可以為該參數(shù)命名或者使用默認(rèn)參數(shù)名oldValue。

注意：

willSet和didSet觀察器在屬性初始化過程中不會被調(diào)用，它們只會當(dāng)屬性的值在初始化之外的地方被設(shè)置時被調(diào)用。

這里是一個willSet和didSet的實際例子，其中定義了一個名為StepCounter的類，用來統(tǒng)計當(dāng)人步行時的總步數(shù)，可以跟計步器或其他日常鍛煉的統(tǒng)計裝置的輸入數(shù)據(jù)配合使用。

    class StepCounter {
        var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            println("About to set totalSteps to \(newTotalSteps)")
        }
        didSet {
            if totalSteps > oldValue  {
                println("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

StepCounter類定義了一個Int類型的屬性totalSteps，它是一個存儲屬性，包含willSet和didSet觀察器。

當(dāng)totalSteps設(shè)置新值的時候，它的willSet和didSet觀察器都會被調(diào)用，甚至當(dāng)新的值和現(xiàn)在的值完全相同也會調(diào)用。

例子中的willSet觀察器將表示新值的參數(shù)自定義為newTotalSteps，這個觀察器只是簡單的將新的值輸出。

didSet觀察器在totalSteps的值改變后被調(diào)用，它把新的值和舊的值進(jìn)行對比，如果總的步數(shù)增加了，就輸出一個消息表示增加了多少步。didSet沒有提供自定義名稱，所以默認(rèn)值oldValue表示舊值的參數(shù)名。

注意：
如果在didSet觀察器里為屬性賦值，這個值會替換觀察器之前設(shè)置的值。

全局變量和局部變量

計算屬性和屬性觀察器所描述的模式也可以用于全局變量和局部變量，全局變量是在函數(shù)、方法、閉包或任何類型之外定義的變量，局部變量是在函數(shù)、方法或閉包內(nèi)部定義的變量。

前面章節(jié)提到的全局或局部變量都屬于存儲型變量，跟存儲屬性類似，它提供特定類型的存儲空間，并允許讀取和寫入。

另外，在全局或局部范圍都可以定義計算型變量和為存儲型變量定義觀察器，計算型變量跟計算屬性一樣，返回一個計算的值而不是存儲值，聲明格式也完全一樣。

注意：
全局的常量或變量都是延遲計算的，跟延遲存儲屬性相似，不同的地方在于，全局的常量或變量不需要標(biāo)記lazy特性。
局部范圍的常量或變量不會延遲計算。

類型屬性

實例的屬性屬于一個特定類型實例，每次類型實例化后都擁有自己的一套屬性值，實例之間的屬性相互獨立。

也可以為類型本身定義屬性，不管類型有多少個實例，這些屬性都只有唯一一份。這種屬性就是類型屬性。

類型屬性用于定義特定類型所有實例共享的數(shù)據(jù)，比如所有實例都能用的一個常量（就像 C 語言中的靜態(tài)常量），或者所有實例都能訪問的一個變量（就像 C 語言中的靜態(tài)變量）。

對于值類型（指結(jié)構(gòu)體和枚舉）可以定義存儲型和計算型類型屬性，對于類（class）則只能定義計算型類型屬性。

值類型的存儲型類型屬性可以是變量或常量，計算型類型屬性跟實例的計算屬性一樣定義成變量屬性。

注意：
跟實例的存儲屬性不同，必須給存儲型類型屬性指定默認(rèn)值，因為類型本身無法在初始化過程中使用構(gòu)造器給類型屬性賦值。

類型屬性語法

在 C 或 Objective-C 中，靜態(tài)常量和靜態(tài)變量的定義是通過特定類型加上global關(guān)鍵字。在 Swift 編程語言中，類型屬性是作為類型定義的一部分寫在類型最外層的花括號內(nèi)，因此它的作用范圍也就在類型支持的范圍內(nèi)。

使用關(guān)鍵字static來定義值類型的類型屬性，關(guān)鍵字class來為類（class）定義類型屬性。下面的例子演示了存儲型和計算型類型屬性的語法：

    struct SomeStructure {
        static var storedTypeProperty = "Some value."
        static var computedTypeProperty: Int {
        // 這里返回一個 Int 值
        }
    }
    enum SomeEnumeration {
        static var storedTypeProperty = "Some value."
        static var computedTypeProperty: Int {
        // 這里返回一個 Int 值
        }
    }
    class SomeClass {
        class var computedTypeProperty: Int {
        // 這里返回一個 Int 值
        }
    }

注意：
例子中的計算型類型屬性是只讀的，但也可以定義可讀可寫的計算型類型屬性，跟實例計算屬性的語法類似。

獲取和設(shè)置類型屬性的值

跟實例的屬性一樣，類型屬性的訪問也是通過點運算符來進(jìn)行，但是，類型屬性是通過類型本身來獲取和設(shè)置，而不是通過實例。比如：

    println(SomeClass.computedTypeProperty)
    // 輸出 "42"

    println(SomeStructure.storedTypeProperty)
    // 輸出 "Some value."
    SomeStructure.storedTypeProperty = "Another value."
    println(SomeStructure.storedTypeProperty)
    // 輸出 "Another value.”

下面的例子定義了一個結(jié)構(gòu)體，使用兩個存儲型類型屬性來表示多個聲道的聲音電平值，每個聲道有一個 0 到 10 之間的整數(shù)表示聲音電平值。

后面的圖表展示了如何聯(lián)合使用兩個聲道來表示一個立體聲的聲音電平值。當(dāng)聲道的電平值是 0，沒有一個燈會亮；當(dāng)聲道的電平值是 10，所有燈點亮。本圖中，左聲道的電平是 9，右聲道的電平是 7。

上面所描述的聲道模型使用AudioChannel結(jié)構(gòu)體來表示：

    struct AudioChannel {
        static let thresholdLevel = 10
        static var maxInputLevelForAllChannels = 0
        var currentLevel: Int = 0 {
        didSet {
            if currentLevel > AudioChannel.thresholdLevel {
                // 將新電平值設(shè)置為閥值
                currentLevel = AudioChannel.thresholdLevel
            }
            if currentLevel > AudioChannel.maxInputLevelForAllChannels {
                // 存儲當(dāng)前電平值作為新的最大輸入電平
                AudioChannel.maxInputLevelForAllChannels = currentLevel
            }
        }
        }
    }

結(jié)構(gòu)AudioChannel定義了 2 個存儲型類型屬性來實現(xiàn)上述功能。第一個是thresholdLevel，表示聲音電平的最大上限閾值，它是一個取值為 10 的常量，對所有實例都可見，如果聲音電平高于 10，則取最大上限值 10（見后面描述）。

第二個類型屬性是變量存儲型屬性maxInputLevelForAllChannels，它用來表示所有AudioChannel實例的電平值的最大值，初始值是 0。

AudioChannel也定義了一個名為currentLevel的實例存儲屬性，表示當(dāng)前聲道現(xiàn)在的電平值，取值為 0 到 10。

屬性currentLevel包含didSet屬性觀察器來檢查每次新設(shè)置后的屬性值，有如下兩個檢查：

• 如果currentLevel的新值大于允許的閾值thresholdLevel，屬性觀察器將currentLevel的值限定為閾值thresholdLevel。
• 如果修正后的currentLevel值大于任何之前任意AudioChannel實例中的值，屬性觀察器將新值保存在靜態(tài)屬性maxInputLevelForAllChannels中。

注意：
在第一個檢查過程中，didSet屬性觀察器將currentLevel設(shè)置成了不同的值，但這時不會再次調(diào)用屬性觀察器。

可以使用結(jié)構(gòu)體AudioChannel來創(chuàng)建表示立體聲系統(tǒng)的兩個聲道leftChannel和rightChannel：

    var leftChannel = AudioChannel()
    var rightChannel = AudioChannel()

如果將左聲道的電平設(shè)置成 7，類型屬性maxInputLevelForAllChannels也會更新成 7：

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

如果試圖將右聲道的電平設(shè)置成 11，則會將右聲道的currentLevel修正到最大值 10，同時maxInputLevelForAllChannels的值也會更新到 10：

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