第10章：属性

  在Swift中枚举、结构体、类都可以有属性，属性描述了类型的某个特性。在Swift中属性从大的方面分可以分为存储属性与计算属性；也可以设置属性的观察者，在属性发生变化前或者属性变化后进行必要的处理。

10.1 存储属性

  在其最简单的形式中，存储属性是一个常量或变量，存储为特定类或结构的实例的一部分。存储属性可以是变量存储属性（由var关键字引入），也可以是常量存储属性（由let关键字引入）。可以为存储属性提供默认值作为其定义的一部分，也可以在初始化期间修改存储属性的值。

// 定义了两个存储属性firstValue和length
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



// 在结构体中，实例被声明为常量，那么无法修改其属性，即使该属性是变量
// 此行为是由于结构是值类型。当值类型的实例标记为常量时，其所有属性也都标记为常量
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

  一般来说属性随着实例的创建而自动创建，但是可能是出于性能原因或者其他原因不希望某些属性在类型实例化时被创建——即希望能够延迟创建某些属性，可以通过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

// 以上代码执行完毕后manager的importer属性没有被创建，直到
print(manager.importer.filename)

10.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)
        }
        // 参见下面的注释，可以省略newCenter
        set(newCenter) {
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
/*
       如果不提供新属性值的变量，那么默认是newValue
       set {
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.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)"

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

注意
您必须将计算属性（包括只读计算属性）声明为带有var关键字的变量属性，因为它们的值不固定。该let关键字仅用于常量属性，以指示一旦将它们设置为实例初始化的一部分，就无法更改它们的值。

struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
     // 可以通过删除get关键字及其大括号来简化只读计算属性的声明
    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"

10.3 属性观察

  您可以将属性观察器添加到您定义的任何存储属性，但惰性存储属性除外。您还可以通过覆盖子类中的属性，将属性观察器添加到任何继承的属性（无论是存储还是计算）。您不需要为非重写的计算属性定义属性观察器，因为您可以在计算属性的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

10.4 类型属性

  实例属性是属于特定类型的实例的属性。每次创建该类型的新实例时，它都有自己的一组属性值，与任何其他实例分开。
  您还可以定义属于该类型本身的属性，而不是该类型的任何一个实例。无论您创建的该类型的实例有多少，这些属性都只会有一个副本。这些属性称为类型属性。
  类型属性对于定义对特定类型的所有实例通用的值很有用，例如所有实例都可以使用的常量属性（如C中的静态常量），或者存储全局值的变量属性该类型的实例（如C中的静态变量）。
  存储的类型属性可以是变量或常量。计算类型属性始终声明为变量属性，与计算实例属性的方式相同。

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

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

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

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