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

时间 2020-07-09

原文原文链接

引言

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

若是你已经掌握这一章节内容，请移步下一章节：方法数据库

属性

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

存储和计算的属性一般与特定类型的实例相关联。可是，属性也能够与类型自己关联。这样的属性称为类属性。数组

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

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

1 存储属性

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

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

下面的示例定义了一个称为FixedLengthRange的结构体，该结构体描述了一个整数范围，该整数范围的长度在建立后不能更改：ide

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值，并将正方形移至新位置。

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的值为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语句检查 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：

上述音频通道由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