Swift5.x-属性（中文文档）

引言

继续学习Swift文档，从上一章节：结构体和类，我们学习了Swift结构体和类相关的内容，如结构体和类的定义和使用、值类型和引用类型的区别、“===”和“!==”符号判断类的实例是否相同等这些内容。现在，我们学习Swift的属性相关的内容。由于篇幅较长，这里分篇来记录，接下来，Fighting！

如果你已经掌握这一章节内容，请移步下一章节：方法

属性

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

存储和计算的属性通常与特定类型的实例相关联。但是，属性也可以与类型本身关联。这样的属性称为类属性。

此外，您可以定义属性观察者以监听属性值的变化，您可以使用自定义操作对其进行响应。可以将属性观察器添加到您自己定义的存储属性中，也可以添加到子类从其超类继承的属性中。

您还可以使用属性包装器在多个属性的getter和setter中重用代码。

1 存储属性

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

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

下面的示例定义了一个称为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的常数存储属性。在上面的示例中，length是在创建新范围时初始化的，此后不能更改，因为它是常量属性。

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

如果您创建结构体的实例并将该实例分配给常量，则即使它们被声明为变量属性，也无法修改实例的属性：

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属性。

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

对于类（引用类型）而言，情况并非如此。如果您将引用类型的实例分配给常量，则仍然可以更改该实例的变量属性。

1.2 懒加载存储属性

懒加载存储属性是其首次使用之前不会计算其初始值的属性。您可以通过在声明之前编写lazy修饰符来表示一个懒加载存储属性。

注意
您必须始终将懒加载属性声明为变量（使用var关键字），因为直到实例初始化完成后才可能检索其初始值。常量属性在初始化完成之前必须始终具有一个值，因此不能声明为lazy的。

当属性的初始值取决于实例初始化完成后才知道其值的外部因素时，lazy属性很有用。当属性的初始值需要复杂或计算量大的设置（除非或直到需要时才执行）时，lazy属性也很有用。

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

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类具有一个称为data的存储属性，该属性使用新的空String数组初始化。尽管未显示其其余功能，但此DataManager类的目的是管理并提供对此String数据数组的访问。

DataManager类的功能的一部分是从文件导入数据的能力。此功能由DataImporter类提供，假定它花费了很短的时间来初始化。这可能是因为在初始化DataImporter实例时，DataImporter实例需要打开文件并将其内容读入内存。

DataManager实例可以在不从文件导入数据的情况下管理其数据，因此在创建DataManager本身时无需创建新的DataImporter实例。相反，如果首次使用DataImporter实例，则在创建它时更有意义。

因为它被标记为lazy修饰符，所以仅在首次访问importer属性时（例如，在查询其filename属性时）才为importer属性创建DataImporter实例：

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

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

1.3 存储属性和实例变量

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

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

2 计算属性

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

本示例定义了用于处理几何形状的三种结构：

Point封装点的x和y坐标。
Size封装了宽度和高度。
Rect通过原点和大小定义一个矩形。

Rect结构还提供了一个称为center的计算属性。 Rect的当前中心位置始终可以根据其原点和大小确定，因此您无需将中心点存储为明确的Point值。取而代之的是，Rect为一个称为center的计算变量定义了一个自定义的getter和setter方法，以使您能够像处理真正的存储属性一样使用矩形的center。

上面的示例创建了一个新的Rect变量，称为square。使用起始点（0，0）以及宽度和高度10初始化square变量。该正方形在下图中由蓝色正方形表示。

然后，通过点语法（square.center）访问square变量的center属性，这将导致调用center的getter来检索当前属性值。 getter实际上不是返回现有值，而是计算并返回一个新的Point来表示正方形的中心。从上面可以看到，正确返回中心点（5，5）。

然后将center属性设置为新值（15，15），该值将正方形向上和向右移动到下图中橙色正方形所示的新位置。设置center属性会调用setter作为center，它会修改存储的原点属性的x和y值，并将正方形移至新位置。

image

2.1 简写setter声明

如果计算属性的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)
        }
    }
}

2.2 简写getter声明

如果getter的整个主体是单个表达式，则getter隐式返回该表达式。这是Rect结构体的另一个版本，它利用了该简写和setter的简写：

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

忽略getter返回的操作遵循与忽略函数返回的操作规则相同，如带Functions With an Implicit Return中所述。

2.3 只读计算属性

具有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"

本示例定义了一个称为Cuboid的新结构，该结构表示具有width，height和depth属性的3D矩形框。此结构还具有一个称为volume的只读计算属性，该属性计算并返回长方体的当前体积。可设置的体积没有意义，因为对于特定的体积值应该使用哪个宽度，高度和深度值是不明确的。但是，对于长方体提供只读的计算属性以使外部用户能够发现其当前的计算量非常有用。

3 属性监听

属性监听观察并响应属性值的变化。每次设置属性值时都会调用属性监听，即使新值与属性的当前值相同也是如此。

您可以在以下位置添加属性监听：

定义的存储属性
继承的存储属性
继承的计算属性

对于继承的属性，可以通过在子类中覆盖该属性来添加属性监听。对于您定义的计算属性，请使用属性的setter来观察并响应值更改，而不是尝试创建观察者。覆盖属性在Overriding中描述。

您可以选择在属性上定义这些观察者之一或全部：

将在存储值之前调用willSet。
存储新值后，将立即调用didSet。

如果您实现了willSet观察者，则会将新的属性值作为常量参数传递。您可以在willSet实现中为该参数指定一个名称。如果您未在实现中写入参数名称和括号，则该参数将用默认参数名称newValue。

同样，如果您实现了didSet观察者，则会传递一个包含旧属性值的常量参数。您可以命名参数或使用默认参数名称oldValue。如果您在自己的didSet观察者中为属性分配值，则分配的新值将替换刚刚设置的值。

注意
在调用父类初始化器之后，在子类初始化器中设置属性时，将调用父类属性的willSet和didSet观察器。在类设置其自己的属性时，在调用父类初始化程序之前，不会调用它们。

有关初始化程序委托的更多信息，请参见Initializer Delegation for Value Types 和 Initializer Delegation for Class Types。

这是willSet和didSet实际使用的示例。下面的示例定义了一个称为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")
            }
        }
    }
}
var stepCounter = StepCounter()  //这里官方文档上用的let，Xcode会报错
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观察者的存储属性。

每当为属性分配新值时，都会调用totalSteps的willSet和didSet观察器。即使新值与当前值相同，也是如此。

此示例的willSet观察者使用自定义参数名称newTotalSteps作为即将到来的新值。在此示例中，它仅打印出将要设置的值。

在更新totalSteps的值之后，将调用didSet观察器。它将totalSteps的新值与旧值进行比较。如果步骤总数增加，则会显示一条消息，指示已执行了多少个新步骤。 didSet观察器没有为旧值提供自定义参数名称，而是使用了默认名称oldValue。

注意
如果将具有观察者的属性作为in-out参数传递给函数，则将始终会调用willSet和didSet观察者。这是因为in-out参数的copy-in、 copy-out内存模型：该值始终在函数结尾设置到该属性上。有关in-out参数行为的详细讨论，请参见 In-Out Parameters。

4 属性包装

属性包装器在管理属性存储方式的代码与定义属性的代码之间增加了一层隔离。例如，如果您具有提供线程安全检查或将其基础数据存储在数据库中的属性，则必须在每个属性上编写该代码。使用属性包装器时，定义包装器时，只需编写一次管理代码，然后通过将其应用于多个属性来重用该管理代码。

要定义属性包装器，您需要创建一个结构体，枚举或类来定义wrappedValue属性。在下面的代码中，TwelveOrLess结构体确保包装的值始终包含小于或等于12的数字。如果您要求存储更大的数字，则改为存储12。

@propertyWrapper
struct TwelveOrLess {
    private var number: Int
    init() { self.number = 0 }
    var wrappedValue: Int {
        get { return number }
        set { number = min(newValue, 12) }
    }
}

setter确保新值小于12，并且getter返回存储的值。

注意
上面示例中的number声明将变量标记为private，这确保了number仅在TwelveOrLess的实现中使用。编写在其他任何地方的代码都使用wrappedValue的getter和setter来访问值，并且不能直接使用数字。有关私有的信息，请参阅Access Control。

通过将包装器的名称写为属性，将包装器的名称应用于属性。这是一个存储小矩形的结构，使用的定义与TwelveOrLess属性封装器所实现的“ small”相同（相当随意）：

struct SmallRectangle {
    @TwelveOrLess var height: Int
    @TwelveOrLess var width: Int
}

var r = SmallRectangle()
print(rectangle.height)
// Prints "0"

rectangle.height = 10
print(rectangle.height)
// Prints "10"

rectangle.height = 24
print(rectangle.height)
// Prints "12"

height和width属性从TwelveOrLess的定义获取其初始值，该定义将TwelveOrLess.number设置为零。将数字10存储到矩形中。成功完成此操作是因为数字很小。尝试存储24实际上存储的是12的值，因为24对于属性设置者的规则来说太大了。

当您将包装器应用于属性时，编译器会合成为包装器提供存储的代码和提供通过包装器访问属性的代码。（属性包装器负责存储包装后的值，因此没有synthesized的代码。）您可以编写使用属性包装器行为的代码，而无需利用特殊的属性语法。例如，这是上一个代码清单中的SmallRectangle版本，该版本将其属性明确地包装在TwelveOrLess结构中，而不是将@TwelveOrLess编写为属性：

struct SmallRectangle {
    private var _height = TwelveOrLess()
    private var _width = TwelveOrLess()
    var height: Int {
        get { return _height.wrappedValue }
        set { _height.wrappedValue = newValue }
    }
    var width: Int {
        get { return _width.wrappedValue }
        set { _width.wrappedValue = newValue }
    }
}

_height和_width属性存储属性包装器TwelveOrLess的实例。高度和宽度的getter和setter包装对wrappedValue属性的访问。

4.1 设置包装属性的初始值

上面示例中的代码通过在TwelveOrLess的定义中给数字一个初始值来设置包装属性的初始值。使用此属性包装器的代码无法为TwelveOrLess所包装的属性指定其他初始值，例如，SmallRectangle的定义无法提供高度或宽度的初始值。为了支持设置初始值或其他自定义，属性包装器需要添加一个初始化程序。这是TwelveOrLess的扩展版本，称为SmallNumber，它定义了设置包装值和最大值的初始化程序：

@propertyWrapper
struct SmallNumber {
    private var maximum: Int
    private var number: Int

    var wrappedValue: Int {
        get { return number }
        set { number = min(newValue, maximum) }
    }

    init() {
        maximum = 12
        number = 0
    }
    init(wrappedValue: Int) {
        maximum = 12
        number = min(wrappedValue, maximum)
    }
    init(wrappedValue: Int, maximum: Int) {
        self.maximum = maximum
        number = min(wrappedValue, maximum)
    }
}

SmallNumber的定义包括三个初始值设定项：init（），init（wrappedValue :)和init（wrappedValue：maximum :)，下面的示例用于设置包裹值和最大值。有关初始化和初始化程序语法的信息，请参见Initialization。

当您将包装器应用于属性时，如果您未指定初始值，则Swift会使用init（）初始化程序来设置包装器。例如：

struct ZeroRectangle {
    @SmallNumber var height: Int
    @SmallNumber var width: Int
}

var zeroRectangle = ZeroRectangle()
print(zeroRectangle.height, zeroRectangle.width)
// Prints "0 0"

包裹height和width的SmallNumber实例是通过调用SmallNumber（）创建的。初始化程序中的代码使用默认值零和12设置初始包装值和初始最大值。属性包装器仍然提供所有初始值，就像之前在SmallRectangle中使用TwelveOrLess的示例一样。

与该示例不同，SmallNumber还支持编写这些初始值作为声明属性的一部分。为属性指定初始值时，Swift使用init（wrappedValue :)初始化程序来设置包装器。例如：

struct UnitRectangle {
    @SmallNumber var height: Int = 1
    @SmallNumber var width: Int = 1
}

var unitRectangle = UnitRectangle()
print(unitRectangle.height, unitRectangle.width)
// Prints "1 1"

当您在具有包装器的属性上写入= 1时，该值将转换为对init（wrappedValue :)初始化程序的调用。包裹高度和宽度的SmallNumber实例是通过调用SmallNumber（wrappedValue：1）创建的。初始化程序使用此处指定的换行值，并使用默认的最大值12。

当您在自定义属性后的括号中写入参数时，Swift将使用接受这些参数的初始化程序来设置包装器。例如，如果您提供一个初始值和一个最大值，Swift将使用init（wrappedValue：maximum :)初始化程序：

struct NarrowRectangle {
    @SmallNumber(wrappedValue: 2, maximum: 5) var height: Int
    @SmallNumber(wrappedValue: 3, maximum: 4) var width: Int
}

var narrowRectangle = NarrowRectangle()
1
// Prints "2 3"

narrowRectangle.height = 100
narrowRectangle.width = 100
print(narrowRectangle.height, narrowRectangle.width)
// Prints "5 4"

包裹高度的SmallNumber实例是通过调用SmallNumber（wrappedValue：2，最大值：5）创建的，包裹宽度的实例是通过调用SmallNumber（wrappedValue：3，最大值：4）创建的。

通过包含属性包装器的参数，您可以在包装器中设置初始状态，或在创建包装器时将其他选项传递给包装器。此语法是使用属性包装器的最通用方法。您可以为属性提供所需的任何参数，然后将它们传递给初始化程序。

当包含属性包装器参数时，还可以使用赋值指定初始值。 Swift将分配视为包装值参数，并使用接受您包含的参数的初始化程序。例如：

struct MixedRectangle {
    @SmallNumber var height: Int = 1
    @SmallNumber(maximum: 9) var width: Int = 2
}

var mixedRectangle = MixedRectangle()
print(mixedRectangle.height)
// Prints "1"

mixedRectangle.height = 20
print(mixedRectangle.height)
// Prints "12"

包裹高度的SmallNumber实例是通过调用SmallNumber（wrappedValue：1）创建的，该实例使用默认的最大值12。包裹宽度的实例是通过调用SmallNumber（wrappedValue：2，最大值：9）创建的。

4.2 从属性包装器投影值

除了包装的值之外，属性包装器还可以通过定义投影值来公开其他功能，例如，管理对数据库的访问的属性包装器可以在其投影值上公开flushDatabaseConnection（）方法。预计值的名称与包装值相同，不同之处在于它以美元符号（ $）开头。由于您的代码无法定义以$ 开头的属性，因此投影值永远不会干扰您定义的属性。

在上面的SmallNumber示例中，如果您尝试将属性设置为太大的数字，则属性包装器会在存储该数字之前对其进行调整。下面的代码将一个projectedValue属性添加到SmallNumber结构中，以跟踪存储属性的包装器在存储新值之前是否调整了该新值。

@propertyWrapper
struct SmallNumber {
    private var number: Int
    var projectedValue: Bool
    init() {
        self.number = 0
        self.projectedValue = false
    }
    var wrappedValue: Int {
        get { return number }
        set {
            if newValue > 12 {
                number = 12
                projectedValue = true
            } else {
                number = newValue
                projectedValue = false
            }
        }
    }
}
struct SomeStructure {
    @SmallNumber var someNumber: Int
}
var someStructure = SomeStructure()

someStructure.someNumber = 4
print(someStructure.$someNumber)
// Prints "false"

someStructure.someNumber = 55
print(someStructure.$someNumber)
// Prints "true"

编写someStructure. $someNumber可访问包装器的投影值。在存储了一个较小的数字（如4）之后，someStructure.$ someNumber的值为false。但是，在尝试存储太大的数字（例如55）后，投影值才是true。

属性包装器可以返回任何类型的值作为其投影值。在此示例中，属性包装器仅公开一条信息（无论数字是否已调整），因此它公开该布尔值作为其投影值。需要公开更多信息的包装器可以返回某个其他数据类型的实例，或者可以返回self以将包装器的实例作为其投影值公开。

当您从属于该类型一部分的代码（例如属性获取器或实例方法）访问投影值时，可以省略self。属性名称之前，就像访问其他属性一样。以下示例中的代码将包装器在高度和宽度周围的投影值称为$height和$width：

enum Size {
    case small, large
}

struct SizedRectangle {
    @SmallNumber var height: Int
    @SmallNumber var width: Int

    mutating func  (to size: Size) -> Bool {
        switch size {
        case .small:
            height = 10
            width = 20
        case .large:
            height = 100
            width = 100
        }
        return $height || $width
    }
}

因为属性包装器语法只是具有getter和setter的属性的语法糖，所以访问height和width的行为与访问任何其他属性的行为相同。例如，resize（to :)中的代码使用其属性包装器访问高度和宽度。如果调用resize（to：.large），则.large的switch case会将矩形的高度和宽度设置为100。包装器将防止这些属性的值大于12，并将投影值设置为true，以记录它调整其值的事实。在resize（to :)的结尾，return语句检查 $height和$ width以确定属性包装器是否调整了高度或宽度。

5 全局和局部变量

上面描述的用于计算和观察属性的功能也可用于全局变量和局部变量。全局变量是在任何函数，方法，闭包或类型上下文之外定义的变量。局部变量是在函数，方法或闭包上下文中定义的变量。

您在上一章中遇到的全局变量和局部变量都已存储。与存储的属性一样，存储的变量为特定类型的值提供存储，并允许设置和检索该值。

但是，您还可以在全局或局部范围内定义计算变量并为存储的变量定义观察者。计算变量将计算其值，而不是存储它的值，并且它们的写法与计算属性的写法相同。

注意
全局常量和变量总是以与懒加载存储属性类似的方式延迟计算。与懒加载存储的属性不同，全局常量和变量不需要使用lazy修饰符进行标记。局部常量和变量绝不会延迟计算。

6 类属性

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

您还可以定义属于类型本身的属性，而不是属于该类型的任何一个实例的属性。无论您创建了多少个该类型的实例，这些属性将永远只有一个副本。这些类型的属性称为类属性。

类属性对于定义特定类型的所有实例通用的值很有用，例如，所有实例可以使用的常量属性（例如C中的静态常量），或存储对所有实例都是全局值的变量属性。该类型的实例（例如C中的静态变量）。

存储的类属性可以是变量或常量。计算类属性始终以与计算实例属性相同的方式声明为变量属性。

注意
与存储实例属性不同，必须始终为存储型属性赋予默认值。这是因为类型本身没有初始化程序，该初始化程序可以在初始化时将值分配给存储的type属性。

存储的类属性在其第一次访问时被延迟初始化。即使它们同时被多个线程访问，也只能将它们初始化一次，并且不需要用lazy修饰符进行标记。

6.1 类属性语法

在C和Objective-C中，将静态常量和与类型关联的变量定义为全局静态变量。但是，在Swift中，类属性被写为类型定义的一部分，位于类型的外部花括号内，每个类属性都明确地限定为其支持的类型。

您可以使用static关键字定义类属性。对于类类型的计算类属性，您可以改用class关键字来允许子类覆盖超类的实现。下面的示例显示了存储和计算的类属性的语法：

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var  : 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
    }
}

注意
上面的计算类属性示例仅适用于只读计算型属性，但是您也可以使用与计算实例属性相同的语法定义可读可写的计算类属性。

6.2 查询和设置类属性

与实例属性一样，查询类属性使用点语法来查询值。但是，类属性使用点语法进行设置值，而不是在该类型的实例上进行设置。例如：

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"

以下示例使用两个存储的类属性作为为多个音频通道的音频电平表建模的结构的一部分。每个通道的音频电平都在0到10之间（含0和10）。

下图说明了如何将这些音频通道中的两个进行组合以模拟立体声音频电平表。当某个通道的音频电平为0时，该通道的所有灯均不点亮。音频级别为10时，该通道的所有指示灯均点亮。在此图中，左声道的当前电平为9，右声道的当前电平为7：

image

上述音频通道由AudioChannel结构体的实例表示：

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

AudioChannel结构体定义了两个存储的类属性以支持其功能。第一个thresholdLevel定义了音频级别可以采用的最大阈值。对于所有AudioChannel实例，此常数均为10。如果音频信号的值大于10，则将其设置为该阈值（如下所述）。

第二个type属性是一个名为maxInputLevelForAllChannels的变量存储属性。这将跟踪任何AudioChannel实例已接收到的最大输入值。它以初始值0开始。

AudioChannel结构体还定义了一个名称为currentLevel的存储实例属性，该属性表示通道的当前音频级别，范围为0到10。

currentLevel属性具有didSet属性观察器，用于在设置currentLevel时检查其值。该观察者执行两项检查：

如果currentLevel的新值大于允许的thresholdLevel，则属性观察器将currentLevel限制为thresholdLevel。
如果currentLevel的新值（在任何上限之后）高于任何AudioChannel实例先前接收的任何值，则属性观察器会将新的currentLevel值存储在maxInputLevelForAllChannels类属性中。

注意
在这两个检查的第一个中，didSet观察器将currentLevel设置为不同的值。但是，这不会导致再次调用观察者。

您可以使用AudioChannel结构体创建两个新的音频通道，分别称为leftChannel和rightChannel，以表示立体声系统的音频级别：

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

如果将左通道的currentLevel设置为7，则可以看到maxInputLevelForAllChannels类属性已更新为等于7：

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

如果您尝试将右侧通道的currentLevel设置为11，则可以看到右侧通道的currentLevel属性的最大值设置为10，并且maxInputLevelForAllChannels类属性更新为等于10：

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

总结

通过这一章节内容，我们知道了：

存储的属性是作为特定类或结构体的实例的一部分存储的常量或变量。
结构体是值类型。当值类型的实例标记为常量时，其所有属性也都标记为常量。
对于类（引用类型）而言，情况并非如此。如果您将引用类型的实例分配给常量，则仍然可以更改该实例的变量属性。
懒加载存储属性是其首次使用之前不会计算其初始值的属性。通过在声明之前编写lazy修饰符来表示一个懒加载存储属性。
只有变量可以设置lazy属性，常量属性在初始化完成之前必须始终具有一个值，因此不能设置lazy。
除了存储的属性外，类，结构和枚举还可以定义计算的属性，这些属性实际上并不存储值。相反，它们提供了一个getter和一个可选的setter，以间接检索和设置其他属性和值。
可以简写setter和getter声明，用newValue默认名称。
只读计算属性可以省略get和花括号，直接return值。
属性监听：willSet和didSet
将在存储值之前调用willSet；
存储新值后，将立即调用didSet。
属性包装：@propertyWrapper关键词。使用属性包装器和定义包装器时，只需编写一次管理代码，然后通过将其应用于多个属性来重用该管理代码。
类属性的语法，可以用static定义类属性。

这一章节内容结束了，有收获的朋友动动手指点个👍哦！

上一章节：结构体和类

下一章节：方法

参考文档：Swift - Properties