★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9729365.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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

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

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

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

存储的属性

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

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

以下示例定义了一个名为的结构FixedLengthRange，该结构描述了一个整数范围，该整数范围的长度在创建后无法更改：

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

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

常量结构实例的存储属性

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

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

因为rangeOfFourItems声明为常量（使用let关键字），所以firstValue即使firstValue是可变属性也无法更改其属性。

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

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

惰性存储的属性

甲_懒惰存储的属性_是一个属性，其初始值是不计算使用它的第一次直到。您可以通过在lazy修饰符的声明之前编写修饰符来指示惰性存储属性。

注意

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

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

下面的示例使用惰性存储的属性，以避免不必要的复杂类的初始化。本示例定义了两个类，分别称为DataImporter和DataManager，没有完整显示：

1. class DataImporter {

2. /*

3. DataImporter is a class to import data from an external file.

4. The class is assumed to take a nontrivial amount of time to initialize.

5. */

6. var filename = "data.txt"

7. // the DataImporter class would provide data importing functionality here

8. }

9. class DataManager {

10. lazy var importer = DataImporter()

11. var data = [String]()

12. // the DataManager class would provide data management functionality here

13. }

14. let manager = DataManager()

15. manager.data.append("Some data")

16. manager.data.append("Some more data")

17. // the DataImporter instance for the importer property has not yet been created

的DataManager类有一个存储属性调用data，这是与一个新的，空数组初始化String的值。尽管未显示其其余功能，但此类的目的DataManager是管理和提供对此String数据数组的访问。

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

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

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

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

注意

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

存储的属性和实例变量

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

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

计算属性

除了存储的属性外，类，结构和枚举还可以定义_计算的属性_，而实际上不存储值。相反，它们提供了一个getter和一个可选的setter，以间接检索和设置其他属性和值。

1. struct Point {
2. var x = 0.0, y = 0.0
3. }
4. struct Size {
5. var width = 0.0, height = 0.0
6. }
7. struct Rect {
8. var origin = Point()
9. var size = Size()
10. var center: Point {
11. get {
12. let centerX = origin.x + (size.width / 2)
13. let centerY = origin.y + (size.height / 2)
14. return Point(x: centerX, y: centerY)
15. }
16. set(newCenter) {
17. origin.x = newCenter.x - (size.width / 2)
18. origin.y = newCenter.y - (size.height / 2)
19. }
20. }
21. }
22. var square = Rect(origin: Point(x: 0.0, y: 0.0),
23. size: Size(width: 10.0, height: 10.0))
24. let initialSquareCenter = square.center
25. square.center = Point(x: 15.0, y: 15.0)
26. print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
27. // Prints "square.origin is now at (10.0, 10.0)"

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

• Point 封装点的x和y坐标。
• Size封装a width和a height。
• Rect 通过原点和大小定义一个矩形。

该Rect结构还提供了称为的计算属性center。a的当前中心位置Rect始终可以通过origin和来确定size，因此您无需将中心点存储为显式Point值。而是Rect为名为的计算变量定义一个自定义的getter和setter方法center，以使您能够center像处理真正的存储属性一样处理矩形。

上面的示例创建了一个Rect名为的新变量square。的square变量被初始化的原点，和的宽度和高度。下图中的蓝色正方形表示该正方形。(0, 0)``10

该square变量的center属性，然后通过点语法（访问square.center），这会导致需要getter center被调用，获取当前的属性值。getter实际上不是返回现有值，而是计算并返回一个新值Point以表示正方形的中心。如上所示，吸气剂正确返回的中心点。(5, 5)

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

速记员声明

如果计算属性的设置器未为要设置的新值定义名称，newValue则使用默认名称。这Rect是利用此速记符号的结构的替代版本：

1. struct AlternativeRect {
2. var origin = Point()
3. var size = Size()
4. var center: Point {
5. get {
6. let centerX = origin.x + (size.width / 2)
7. let centerY = origin.y + (size.height / 2)
8. return Point(x: centerX, y: centerY)
9. }
10. set {
11. origin.x = newValue.x - (size.width / 2)
12. origin.y = newValue.y - (size.height / 2)
13. }
14. }
15. }

速记吸气剂声明

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

1. struct CompactRect {
2. var origin = Point()
3. var size = Size()
4. var center: Point {
5. get {
6. Point(x: origin.x + (size.width / 2),
7. y: origin.y + (size.height / 2))
8. }
9. set {
10. origin.x = newValue.x - (size.width / 2)
11. origin.y = newValue.y - (size.height / 2)
12. }
13. }
14. }

return从getter 省略the 遵循与return从函数省略相同的规则，如具有隐式返回的函数中所述。

只读计算属性

具有getter但不包含setter的_计算属性_称为_只读计算属性_。只读的计算属性始终返回一个值，并且可以通过点语法进行访问，但不能将其设置为其他值。

注意

您必须使用var关键字将计算属性（包括只读计算属性）声明为变量属性，因为它们的值不固定。该let关键字仅用于恒定的特性，以表明一旦它们被设置为实例的初始化的一部分，不能改变它们的值。

您可以通过删除get关键字及其括号来简化对只读计算属性的声明：

1. struct Cuboid {
2. var width = 0.0, height = 0.0, depth = 0.0
3. var volume: Double {
4. return width * height * depth
5. }
6. }
7. let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
8. print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
9. // Prints "the volume of fourByFiveByTwo is 40.0"

这个例子定义了一个新的结构叫做Cuboid，其表示与3D矩形框width，height和depth特性。此结构还具有称为的只读计算属性volume，该属性计算并返回长方体的当前体积。它没有任何意义的volume是可调节的，因为这将是模棱两可至于哪些值width，height以及depth应该用于特定的volume值。尽管如此，Cuboid提供一个只读的计算属性以使外部用户能够发现其当前的计算量对于a还是有用的。

物业观察员

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

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

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

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

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

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

注意

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

有关初始化委派的详细信息，请参阅初始化函数代表团值类型和初始值设定代表团类的类型。

下面是一个例子willSet，并didSet在行动。下面的示例定义了一个名为的新类StepCounter，该类跟踪一个人在走路时所走的总步数。此类可以与计步器或其他计步器的输入数据一起使用，以跟踪一个人的日常活动。

1. class StepCounter {
2. var totalSteps: Int = 0 {
3. willSet(newTotalSteps) {
4. print("About to set totalSteps to \(newTotalSteps)")
5. }
6. didSet {
7. if totalSteps > oldValue {
8. print("Added \(totalSteps - oldValue) steps")
9. }
10. }
11. }
12. }
13. let stepCounter = StepCounter()
14. stepCounter.totalSteps = 200
15. // About to set totalSteps to 200
16. // Added 200 steps
17. stepCounter.totalSteps = 360
18. // About to set totalSteps to 360
19. // Added 160 steps
20. stepCounter.totalSteps = 896
21. // About to set totalSteps to 896
22. // Added 536 steps

在StepCounter类声明了一个totalSteps类型的属性Int。这是willSet和didSet观察者的存储属性。

在willSet和didSet观察员totalSteps每当属性分配一个新的值被调用。即使新值与当前值相同，也是如此。

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

该didSet观测器的值后调用totalSteps被更新。它将的新值totalSteps与旧值进行比较。如果步骤总数增加，则会显示一条消息，指示已执行了多少个新步骤。该didSet观察者不提供旧值自定义参数名称，默认的名称oldValue来代替。

注意

如果将具有观察者的属性作为输入输出参数传递给函数，则始终调用willSet和didSet观察者。这是由于in-out参数的in-in copy-out内存模型：该值始终在函数末尾写回到该属性。有关输入输出参数行为的详细讨论，请参见输入输出参数。

物业包装

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

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

1. @propertyWrapper
2. struct TwelveOrLess {
3. private var number: Int
4. init() { self.number = 0 }
5. var wrappedValue: Int {
6. get { return number }
7. set { number = min(newValue, 12) }
8. }
9. }

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

注意

上例中的声明number将变量标记为private，这确保number仅在的实现中使用TwelveOrLess。在其他地方编写的代码使用的getter和setter访问值wrappedValue，并且不能number直接使用。有关的信息private，请参阅访问控制。

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

1. struct SmallRectangle {

2. @TwelveOrLess var height: Int

3. @TwelveOrLess var width: Int

4. }

5. var rectangle = SmallRectangle()

6. print(rectangle.height)

7. // Prints "0"

8. rectangle.height = 10

9. print(rectangle.height)

10. // Prints "10"

11. rectangle.height = 24

12. print(rectangle.height)

13. // Prints "12"

在height和width来自定义性能得到它们的初始值TwelveOrLess，它设置TwelveOrLess.number为零。rectangle.height因为数字很小，所以将数字10存储到成功。尝试存储24实际上会存储值12，因为24对于属性设置程序的规则而言太大。

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

1. struct SmallRectangle {
2. private var _height = TwelveOrLess()
3. private var _width = TwelveOrLess()
4. var height: Int {
5. get { return _height.wrappedValue }
6. set { _height.wrappedValue = newValue }
7. }
8. var width: Int {
9. get { return _width.wrappedValue }
10. set { _width.wrappedValue = newValue }
11. }
12. }

在_height和_width属性存储属性包装的一个实例，TwelveOrLess。获取height和width包装对wrappedValue属性的访问权的setter和setter 。

设置包装属性的初始值

上面示例中的代码通过number在的定义中提供初始值来设置wrapd属性的初始值TwelveOrLess。使用此属性包装器的代码无法为被包装的属性指定其他初始值，TwelveOrLess例如，SmallRectangle不能给出height或width初始值的定义。为了支持设置初始值或其他自定义，属性包装器需要添加一个初始化程序。下面是一个扩大版TwelveOrLess叫SmallNumber那一套包裹和最大值定义初始化：

1. @propertyWrapper

2. struct SmallNumber {

3. private var maximum: Int

4. private var number: Int

5. var wrappedValue: Int {

6. get { return number }

7. set { number = min(newValue, maximum) }

8. }

9. init() {

10. maximum = 12

11. number = 0

12. }

13. init(wrappedValue: Int) {

14. maximum = 12

15. number = min(wrappedValue, maximum)

16. }

17. init(wrappedValue: Int, maximum: Int) {

18. self.maximum = maximum

19. number = min(wrappedValue, maximum)

20. }

21. }

的定义SmallNumber包括三个初始化程序init()，init(wrappedValue:)和init(wrappedValue:maximum:)，下面的示例使用这些初始化程序来设置包装的值和最大值。有关初始化和初始化程序语法的信息，请参见Initialization。

当您将包装器应用于属性并且未指定初始值时，Swift使用init()初始化程序来设置包装器。例如：

1. struct ZeroRectangle {

2. @SmallNumber var height: Int

3. @SmallNumber var width: Int

4. }

5. var zeroRectangle = ZeroRectangle()

6. print(zeroRectangle.height, zeroRectangle.width)

7. // Prints "0 0"

SmallNumberwrap height和的实例width是通过调用创建的SmallNumber()。该初始化中的代码设置初始包裹值和初始最大值，使用的零和12的默认值的属性包装仍然提供所有的初始值的，如所使用的前面的例子TwelveOrLess在SmallRectangle。与该示例不同，SmallNumber它还支持编写那些初始值作为声明属性的一部分。

当您为属性指定初始值时，Swift使用init(wrappedValue:)初始化程序来设置包装器。例如：

1. struct UnitRectangle {

2. @SmallNumber var height: Int = 1

3. @SmallNumber var width: Int = 1

4. }

5. var unitRectangle = UnitRectangle()

6. print(unitRectangle.height, unitRectangle.width)

7. // Prints "1 1"

当您使用包装器在属性上书写时，该属性将转换为对初始化程序的调用。wrap 和的实例是通过调用创建的。初始化程序使用此处指定的包装值，并且使用默认最大值12。= 1``init(wrappedValue:)``SmallNumber``height``width``SmallNumber(wrappedValue: 1)

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

1. struct NarrowRectangle {

2. @SmallNumber(wrappedValue: 2, maximum: 5) var height: Int

3. @SmallNumber(wrappedValue: 3, maximum: 4) var width: Int

4. }

5. var narrowRectangle = NarrowRectangle()

6. print(narrowRectangle.height, narrowRectangle.width)

7. // Prints "2 3"

8. narrowRectangle.height = 100

9. narrowRectangle.width = 100

10. print(narrowRectangle.height, narrowRectangle.width)

11. // Prints "5 4"

的实例SmallNumber，它包装height是通过调用创建，以及包装的实例是通过调用创建。SmallNumber(wrappedValue: 2, maximum: 5)``width``SmallNumber(wrappedValue: 3, maximum: 4)

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

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

1. struct MixedRectangle {

2. @SmallNumber var height: Int = 1

3. @SmallNumber(maximum: 9) var width: Int = 2

4. }

5. var mixedRectangle = MixedRectangle()

6. print(mixedRectangle.height)

7. // Prints "1"

8. mixedRectangle.height = 20

9. print(mixedRectangle.height)

10. // Prints "12"

SmallNumber包装的实例height是通过调用创建的，该实例使用默认的最大值12。包装的实例是通过调用创建的。SmallNumber(wrappedValue: 1)``width``SmallNumber(wrappedValue: 2, maximum: 9)

从属性包装器投射值

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

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

1. @propertyWrapper

2. struct SmallNumber {

3. private var number: Int

4. var projectedValue: Bool

5. init() {

6. self.number = 0

7. self.projectedValue = false

8. }

9. var wrappedValue: Int {

10. get { return number }

11. set {

12. if newValue > 12 {

13. number = 12

14. projectedValue = true

15. } else {

16. number = newValue

17. projectedValue = false

18. }

19. }

20. }

21. }

22. struct SomeStructure {

23. @SmallNumber var someNumber: Int

24. }

25. var someStructure = SomeStructure()

26. someStructure.someNumber = 4

27. print(someStructure.$someNumber)

28. // Prints "false"

29. someStructure.someNumber = 55

30. print(someStructure.$someNumber)

31. // Prints "true"

写入someStructure.$someNumber访问包装器的预计值。存储样四少数后，的值someStructure.$someNumber是false。但是，预计值是true在尝试存储太大的数字（如55 ）之后得出的。

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

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

1. enum Size {

2. case small, large

3. }

4. struct SizedRectangle {

5. @SmallNumber var height: Int

6. @SmallNumber var width: Int

7. mutating func resize(to size: Size) -> Bool {

8. switch size {

9. case .small:

10. height = 10

11. width = 20

12. case .large:

13. height = 100

14. width = 100

15. }

16. return $height || $width

17. }

18. }

因为属性包装器语法只是具有getter和setter的属性的语法糖，所以访问height和width行为与访问任何其他属性相同。例如，resize(to:)访问中的代码height及其width使用的属性包装器。如果调用，则切换用例将矩形的高度和宽度设置为100。包装程序将防止这些属性的值大于12，并且将投影值设置为，以记录其调整其值的事实。最后，return语句检查并确定属性包装器是否已调整或。resize(to: .large)``.large``true``resize(to:)``$height``$width``height``width

全局和局部变量

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

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

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

注意

全局常量和变量总是以与惰性存储属性类似的方式延迟计算。与惰性存储的属性不同，全局常量和变量不需要用lazy修饰符标记。

局部常量和变量绝不会延迟计算。

类型属性

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

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

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

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

注意

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

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

类型属性语法

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

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

1. struct SomeStructure {
2. static var storedTypeProperty = "Some value."
3. static var computedTypeProperty: Int {
4. return 1
5. }
6. }
7. enum SomeEnumeration {
8. static var storedTypeProperty = "Some value."
9. static var computedTypeProperty: Int {
10. return 6
11. }
12. }
13. class SomeClass {
14. static var storedTypeProperty = "Some value."
15. static var computedTypeProperty: Int {
16. return 27
17. }
18. class var overrideableComputedTypeProperty: Int {
19. return 107
20. }
21. }

注意

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

查询和设置类型属性

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

1. print(SomeStructure.storedTypeProperty)
2. // Prints "Some value."
3. SomeStructure.storedTypeProperty = "Another value."
4. print(SomeStructure.storedTypeProperty)
5. // Prints "Another value."
6. print(SomeEnumeration.computedTypeProperty)
7. // Prints "6"
8. print(SomeClass.computedTypeProperty)
9. // Prints "27"

以下示例使用两个存储的类型属性作为为多个音频通道的音频电平表建模的结构的一部分。每个通道的整数音频电平介于0和之间10。

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

上述音频通道由以下AudioChannel结构实例表示：

1. struct AudioChannel {
2. static let thresholdLevel = 10
3. static var maxInputLevelForAllChannels = 0
4. var currentLevel: Int = 0 {
5. didSet {
6. if currentLevel > AudioChannel.thresholdLevel {
7. // cap the new audio level to the threshold level
8. currentLevel = AudioChannel.thresholdLevel
9. }
10. if currentLevel > AudioChannel.maxInputLevelForAllChannels {
11. // store this as the new overall maximum input level
12. AudioChannel.maxInputLevelForAllChannels = currentLevel
13. }
14. }
15. }
16. }

该AudioChannel结构定义了两个存储的类型属性以支持其功能。第一个thresholdLevel定义音频电平可以采用的最大阈值。10对于所有AudioChannel实例，这是一个恒定值。如果音频信号的值大于10，它将被限制为该阈值（如下所述）。

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

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

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

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

注意

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

您可以使用该AudioChannel结构创建两个名为leftChannel和的新音频通道rightChannel，以表示立体声系统的音频电平：

1. var leftChannel = AudioChannel()
2. var rightChannel = AudioChannel()

如果currentLevel将_左_通道的设置为，则7可以看到maxInputLevelForAllChannelstype属性已更新为equal 7：

1. leftChannel.currentLevel = 7
2. print(leftChannel.currentLevel)
3. // Prints "7"
4. print(AudioChannel.maxInputLevelForAllChannels)
5. // Prints "7"

如果您尝试currentLevel将_右侧_通道的设置为，则11可以看到右侧通道的currentLevel属性被限制为的最大值10，并且maxInputLevelForAllChannelstype属性被更新为equal 10：

1. rightChannel.currentLevel = 11
2. print(rightChannel.currentLevel)
3. // Prints "10"
4. print(AudioChannel.maxInputLevelForAllChannels)
5. // Prints "10"