Swift4.2_属性

官网链接

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

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

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

• 存储属性 (Stored Properties)

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

下面的示例定义了一个名为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.常量结构体实例的存储属性 (Stored Properties of Constant Structure Instances)

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

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是一个变量属性。

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

对于引用类型的类，情况就不一样了。如果将引用类型的实例分配给常量，仍然可以更改该实例的变量属性。

2.延迟储存属性 (Lazy Stored Properties)

延迟存储属性的初始值在其第一次使用时才进行计算。声明前标注lazy修饰语来表示一个延迟存储属性。且声明必须为变量。

NOTE
必须始终将lazy属性声明为变量（使用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

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

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

NOTE
如果同时由多个线程访问标记为lazy修饰符的属性且该属性尚未初始化，则无法保证该属性仅初始化一次。

3.储存属性与实例变量 (Stored Properties and Instance Variables)

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

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

• 计算属性 (Computed Properties)

除了存储的属性之外，类，结构和枚举还可以定义计算属性，这些属性实际上不存储值。 相反，它们提供了一个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))
//走setter方法
let initialSquareCenter = square.center
//走getter方法
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)"

上面代码如果有不明白的可以打断的运行一下，就不做啰嗦的解释了,下图作为参考。

image.png
1.简写设置器(setter)声明 (Shorthand Setter Declaration)

如果计算属性的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.只读计算属性 (Read-Only Computed Properties)

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

NOTE
必须使用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"

• 属性观察者 (Property Observers)

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

你可以向定义的任何存储属性添加属性观察者，延迟存储属性除外。您还可以通过重写子类中的属性向任何继承的属性(无论是存储的还是计算的)添加属性观察者。您不需要为未重写的计算属性定义属性观察者，因为您可以在计算属性的setter中观察并响应对其值的更改。

您可以选择在属性上定义其中一个或两个观察者：

willSet在存储值之前调用。
存储新值后立即调用didSet。
如果实现了一个willSet观察者，它会将新属性值作为常量参数传递。 您可以在willSet实现中指定此参数的名称。 如果未在实现中编写参数名称和括号，则该参数将使用默认参数名称newValue。

类似地，如果实现didSet观察者，它将传递一个常量参数，其中包含旧属性值。你可以命名参数或使用oldValue的默认参数名称。如果你将一个值赋给它自己的didSet观察者中的属性，那么你所赋的新值将替换刚刚设置的值。

NOTE
在调用父类初始值设定项之后，在子类初始值设定项中设置属性时，将调用父类属性的willSet和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

NOTE
如果将具有观察者的属性作为输入输出参数传递给函数，则始终会调用willSet和didSet观察者。 这是因为in-out参数的copy-in copy-out内存模型：该值总是写回函数末尾的属性。

• 全局和局部变量 (Global and Local Variables)

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

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

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

局部常数和变量永远不会被延迟计算。

• 类型属性 (Type Properties)

可以定义属于类型本身的属性，不是这个类型的某一个实例的属性。这个属性只有一个拷贝，无论你创建了多少个类对应的实例。这样的属性叫做类型属性。

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

NOTE
与存储的实例属性不同，您必须始终为存储的类型属性提供默认值。 这是因为类型本身没有初始化程序，可以在初始化时为存储的类型属性赋值。
存储类型属性在首次访问时会被初始化。 它们保证只初始化一次，即使同时由多个线程访问，也不需要使用延迟修饰符进行标记。

1.类型属性语法 (Type Property Syntax)

使用static关键字定义类型属性

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

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

2.查询和设置类型属性 (Querying and Setting Type Properties)

类型属性被查询并使用点语法设置，就像实例属性一样。但是，类型属性是在类型上查询和设置的，而不是在该类型的实例上。例如:

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.png

上述音频通道由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结构创建两个名为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"