存储属性

在其最简单的形式中，存储属性是作为特定类或结构的实例的一部分存储的常量或变量。 存储的属性可以是变量存储属性（由var关键字引入）或常量存储属性（由关键字引入）。

您可以为存储属性提供默认值，作为其定义的一部分，如默认属性值中所述。 您还可以在初始化期间设置和修改存储属性的初始值。 即使对于常量存储的属性也是如此，如在初始化期间分配常量属性中所述。

下面的示例定义了一个称为FixedLengthRange的结构，它描述了一系列整数，其范围长度在创建后无法更改：

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

FixedLengthRange的实例具有称为firstValue的变量存储属性和称为length的常量存储属性。 在上面的示例中，长度在创建新范围时初始化，并且之后无法更改，因为它是常量属性。

常量结构实例的存储属性

如果创建结构的实例并将该实例分配给常量，那么即使它们被声明为变量属性，也不能修改实例的属性：

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

因为rangeOfFourItems被声明为一个常量（使用let关键字），所以不可能改变它的firstValue属性，即使firstValue是一个变量属性。

这种行为是由于结构是值类型。 当值类型的实例被标记为常量时，其所有属性也是如此。

对于作为引用类型的类则不是这样。 如果将引用类型的实例指定给常量，则仍然可以更改该实例的变量属性。

延迟存储属性

延迟存储属性是一种属性，其初始值不会在第一次使用时计算。 你通过在声明之前写入lazy修饰符来指示一个惰性存储属性。

注意：
您必须始终将lazy属性声明为变量（使用var关键字），因为它的初始值可能无法在实例初始化完成后检索。 常量属性在初始化完成之前必须始终具有值，因此不能声明为延迟。

下面的示例使用延迟存储属性，以避免不必要的复杂类的初始化。 此示例定义了两个名为DataImporter和DataManager的类，这两个类都不完整显示：

class DataImporter {
    /*
     DataImporter is a class to import data from an external file.
     The class is assumed to take a non-trivial 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

因为它用lazy修饰符标记，所以只有在首次访问importer属性时才会创建importer属性的DataImporter实例，例如查询其fileName属性时：

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

如果标记有lazy修饰符的属性由多个线程同时访问，并且该属性尚未初始化，则不能保证该属性只被初始化一次。

存储属性和实例变量

如果你有Objective-C的经验，你可能知道它提供了两种方法来存储值和引用作为类实例的一部分。 除了属性，您可以使用实例变量作为存储在属性中的值的后备存储。

Swift将这些概念统一到单个属性声明中。 Swift属性没有对应的实例变量，并且不直接访问属性的后备存储。 这种方法避免了对在不同上下文中如何访问值的混淆，并将属性的声明简化为单个确定的语句。 有关属性的所有信息（包括其名称，类型和内存管理特性）在单个位置中定义为类型定义的一部分。

计算属性

除了存储的属性，类，结构和枚举可以定义计算属性，实际上不存储值。 相反，它们提供了一个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)"

速记组合声明

如果计算属性的setter未定义要设置的新值的名称，则使用缺省名称newValue。 这里有一个替代版本的Rect结构，它利用了这个简写符号：

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"

属性观察者

属性观察者观察并响应属性值的变化。 每次设置属性的值时，都会调用属性观察器，即使新值与属性的当前值相同。

您可以将属性观察器添加到您定义的任何存储的属性，lazy存储属性除外。 您还可以通过覆盖子类中的属性，将属性观察器添加到任何继承的属性（无论是存储还是计算）。 您不需要为未覆盖的计算属性定义属性观察器，因为您可以在计算属性的setter中观察并响应对其值的更改。 属性覆盖在覆盖中描述。

您可以选择在属性上定义这两个观察者之一：

• willSet在值被存储之前被调用。
• didSet在存储新值之后立即调用。

如果你实现一个willSet观察者，它作为一个常量参数传递新的属性值。 您可以为此参数指定名称，作为您的willSet实现的一部分。 如果不在实现中写入参数名称和括号，那么该参数的缺省参数名称为newValue。

类似地，如果你实现一个didSet观察者，它传递一个常量参数包含旧的属性值。 您可以命名参数或使用默认参数名称oldValue。 如果您为自己的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

注意：
如果将一个具有观察者的属性作为一个in-out参数传递给一个函数，willSet和didSet观察者总是被调用。 这是因为用于输入输出参数的复制输入输出存储器模型：该值始终写回函数结尾处的属性。 有关输入 - 输出参数行为的详细讨论，请参阅输入 - 输出参数。