属性

属性将值与特定的类、结构体或枚举相关联，分为存储型属性和计算型属性。存储型属性将常量和变量值存储为实例的一部分，计算型属性存储值。计算型属性可由类、结构体和枚举提供，存储型属性仅由类和结构体提供。

可以定义属性观察器来监听值的更改，也可以自定义操作响应。属性观察器可以添加到存储型属性中，也可以添加到子类从其超类继承的属性。

<br />

存储型属性

存储型属性是作为特定类或结构的实例的一部分存储的常量或变量。可以提供默认值，也可以在初始化期间设置和修改存储型属性的初始值，即便是常量属性也可如此。

struct FixedLengthRange {
    var firstValue: Int
    let length: Int
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
// the range represents integer values 0, 1, and 2
rangeOfThreeItems.firstValue = 6
// the range now represents integer values 6, 7, and 8

常量结构体实例的存储型属性

若创建一个结构体实例并将其分配给常量，即便结构体属性为变量，也不能修改该实例的属性。

let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// this range represents integer values 0, 1, 2, and 3
rangeOfFourItems.firstValue = 6
// this will report an error, even though firstValue is a variable property

由于结构体是值类型，当值类型的实例被标记为常量时，其所有属性都被标记为常量。

而类是引用类型，当引用类型的实例分配给变量时，仍然可以修改该实例的变量属性。

延迟存储型属性

延迟存储型属性是其初始值在第一次使用之前不会被计算，且必须声明为变量var，在声明属性前添加lazy关键字。

当有以下情况时将存储型属性声明为延迟属性：

• 属性的初始值在实例初始化之前无法确定
• 属性的初始值设置复杂或计算昂贵

以下为使用延迟属性来避免复杂类不必要的初始化：

class DataImporter {
    /*
     DataImporter is a class to import data from an external file.
     The class is assumed to take a nontrivial amount of time to initialize.
     */
    var filename = "data.txt"
    // the DataImporter class would provide data importing functionality here
}
 
class DataManager {
    lazy var importer = DataImporter()
    var data = [String]()
    // the DataManager class would provide data management functionality here
}
 
let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")
// the DataImporter instance for the importer property has not yet been created

DataManager类有一个DataImporter类提供的从文件中导入数据的功能，DataImporter类初始化时需要打开文件并将内容读入内存。首先，该过程需要耗费初始化时间，此外，DataManager类用来管理数据而无需从文件导入数据。所以importer属性在首次使用DataImporter实例时才使用更具意义。

print(manager.importer.filename)
// the DataImporter instance for the importer property has now been created
// Prints "data.txt"

注意

延迟属性是线程不安全的，当尚未初始化的延迟属性同时被多个线程访问，不能保证该属性仅被初始化一次。

<br />

计算型属性

类、结构体和枚举可以定义计算型属性，计算型属性不存储值，提供一个getter和可选setter方法间接获取和设置其他属性和值。

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))")
// Prints "square.origin is now at (10.0, 10.0)"

Rect结构体有一个名为center的计算型属性，其值由结构体属性origin和size确定，在其getter方法中定义这种确定关系，而其setter方法可同时改变origin属性值。

setter声明简写

若计算型属性的setter未定义要设置的新值的名称，则使用默认名称newValue。

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方法的计算型属性为只读计算型属性。只读计算型属性始终返回一个值，只能通过点语法访问，而无法设置其值。

注意

计算型属性(包括只读计算型属性)必须声明为变量var，因为其值不是固定的。常量let属性则表示其值被初始化后无法修改。

只读计算型属性可以忽略get关键字和大括号以简化声明：

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)")
// Prints "the volume of fourByFiveByTwo is 40.0"

<br />

属性观察器

属性观察器监听并响应属性值的变化，即便新值与当前值相同，在每次设置属性值时也会调用属性观察器。

除延迟属性外的任何存储型属性都可以设置属性观察器，也可以通过重写子类属性将属性观察器添加到任何继承属性(无论是存储型还是计算型属性)。非重写计算型属性无法添加属性观察器，因为可以通过计算型属性的setter来观察和响应其值的改变。

根据实际情况定义以下属性观察器中的一个或两个：

• willSet在存储该前调用
• didSet在存储新值后立即调用

若实现willSet观察器，新属性值作为常量参数传入，该值在未指定名称的情况下默认为newValue。

若实现didSet观察器，旧属性值作为常量参数传入，该值在未指定名称的情况下默认为oldValue。

注意

在调用超类初始化器后，并在子类初始化器设置属性时，会调用超类属性的willSet和willSet，它们在类调用超类初始化器之前设置属性值则不会被调用。

以下为一个跟踪步行总步数的StepCounter类，该类可能与计步器输入数据一起使用：

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

<br />

类型属性

实例属性是属于特定类型实例的属性，每次创建该类型的新实例时，它都有一个与其他实例分开的自己的一组属性值。

而类型属性是只属于类型本身的属性值，不是该类型的任何一个实例。无论创建多少个该类型的实例，该类型属性只有一个副本。

类型属性可用于定义通用于特定类型的所有实例的值，如所有实例都可使用的常量属性(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)
// Prints "Some value."
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
// Prints "Another value."
print(SomeEnumeration.computedTypeProperty)
// Prints "6"
print(SomeClass.computedTypeProperty)
// Prints "27"

下面为音频频道的结构体示例：

struct AudioChannel {
    static let thresholdLevel = 10
    static var maxInputLevelForAllChannels = 0
    var currentLevel: Int = 0 {
        didSet {
            if currentLevel > AudioChannel.thresholdLevel {
                // cap the new audio level to the threshold level
                currentLevel = AudioChannel.thresholdLevel
            }
            if currentLevel > AudioChannel.maxInputLevelForAllChannels {
                // store this as the new overall maximum input level
                AudioChannel.maxInputLevelForAllChannels = currentLevel
            }
        }
    }
}

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

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

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