Swift 3.0之十、属性

2017-01-06 本文已影响19人麟young

1. 存储属性

存储属性包括变量存储属性(由var关键字修饰)和常量存储属性(由let关键字修饰)。

// 定义了一个名为 FixedLengthRange 的结构体
struct FixedLengthRange {
    var firstValue: Int   // 变量存储属性
    let length: Int       // 常量存储属性
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
// rangeOfThreeItems 代表整数范围为 0, 1, 2
rangeOfThreeItems.firstValue = 6
// rangeOfThreeItems 的整数范围现在为 6, 7, 8

注意: 上面栗子中，rangeOfThreeItems实例一旦创建并为常量属性length分配值，则length不能再赋新值，这也是常量属性和变量属性的根本区别。

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

如果把结构体的实例赋给常量，则不能修改这个实例的属性，即使是声明为变量的属性:

let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// rangeOfFourItems表示的整数范围为 0, 1, 2, 3
rangeOfFourItems.firstValue = 6
// 即使firstValue是变量属性，这里也会报错，因为rangeOfFourItems是一个常量结构体

总结: 由于结构体是值类型，当一个值类型的实例被标记为常量时，该实例的其他属性也均为常量。
而类是引用类型，给一个常量赋值引用类型实例，仍可以修改那个实例的变量属性。

延迟存储属性

延迟存储属性的初始值在其第一次使用时才进行计算，可以通过lazy var修饰语来表示一个延迟存储属性。(延迟存储属性一定是变量，因为它的初始值可能在实例初始化完成之前无法取得。常量属性则必须在初始化完成之前有值，因此不能声明为延迟。)
举个栗子:

// 假装DataImporter类用来导入数据，是一项耗时的操作。
class DataImporter {
    var fileName = "data.txt"
}
 
// 假装DataManager类用来管理数据
class DataManager {
    lazy var importer = DataImporter()
    var data = [String]()
}
 
let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")
// manager初始化后，其importer属性并未赋值给它一个DataManager类的实例，
// 因为它是lazy修饰的延迟存储属性，只有第一次使用它时这个属性才会真正被赋值，如:

print(manager.importer.fileName)
// 此时DataManager的实例被创建，并赋值给manager的importer属性
// 结果为: "data.txt"

注意: 如果被标记为lazy修饰符的属性同时被多个线程访问并且属性还没有被初始化，则无法保证属性只初始化一次。

2. 计算属性

计算属性并不存储值，只提供一个读取器和一个可选的设置器来间接得到和设置其属性值。举个栗子:

// 结构体Point表示一个点的位置
struct Point {
    var x = 0.0, y = 0.0
}

// 结构体Size表示图形的尺寸
struct Size {
    var width = 0.0, height = 0.0
}

// 结构体Rect表示一个矩形
struct Rect {
    var origin = Point()   // 矩形的原点
    var size = Size()      // 矩形的尺寸
    var center: Point {    // 用计算属性来表示矩形的中心点的位置
        get {              // 读取器get{} 中表示获取center属性的逻辑
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set(newCenter) {   // 设置器set{} 中表示设置center属性时参与的逻辑，
                           // 这里改变了矩形原点的位置
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
    }
}

// 创建一个矩形的实例给变量square  (0.0, 0.0, 10.0, 10.0)
var square = Rect(origin: Point(x: 0.0, y: 0.0),
    size: Size(width: 10.0, height: 10.0))
// 用常量initialSquareCenter表示此事矩形的中心点位置
let initialSquareCenter = square.center
// 打印出来，结果为:square.center is at (5.0, 5.0)
print("square.center is at (\(initialSquareCenter.x), \(initialSquareCenter.y)")
// 将矩形的中心点设置为(15.0, 15.0)
square.center = Point(x: 15.0, y: 15.0)
// 此时矩形原点的位置也发生改变，结果为: "square.origin is now at (10.0, 10.0)"
print("square.origin is now at (\(square.origin.x), \(square.origin.y))")

简写设置器（setter）声明

如果一个计算属性的设置器没有为将要被设置的值定义一个名字，那么他将被默认命名为newValue。举个栗子:

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 { // newValue 是设置器的默认参数
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.y - (size.height / 2)
        }
    }
}

只读计算属性

一个有读取器但是没有设置器的计算属性就是所谓的只读计算属性。只读计算属性返回一个值，也可以通过点语法访问，但是不能被修改为另一个值。语法上，可以通过去掉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)")
// 结果为: "the volume of fourByFiveByTwo is 40.0"

注意，包括只读计算属性，所有计算属性一律用var来修饰，因为计算属性的值不确定。计算属性可以由类、结构体和枚举定义；存储属性只能由类和结构体定义。

3. 属性观察者

属性观察者会观察并对属性值的变化做出回应。
可以为定义的任意存储属性添加属性观察者，除了延迟存储属性。
willSet在该值被存储之前被调用。（默认参数名字为newValue）
didSet在一个新值被存储后被调用。（默认参数名字为oldValue）

举个栗子:

class StepCounter {
    var totalSteps: Int = 0 {     
        willSet(newTotalSteps) {        // 创建willSet观察者(自定义newTotalSteps参数)
            print("About to set totalSteps to \(newTotalSteps)")
        }
        didSet {
            if totalSteps > oldValue  { // 创建didSet观察者(使用默认参数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

4. 全局和局部变量

全局变量是定义在任何函数、方法、闭包或者类型环境之外的变量。局部变量是定义在函数、方法或者闭包环境之中的变量。
全局常量和变量永远是延迟计算的，与延迟存储属性有着相同的行为。不同于延迟存储属性，全局常量和变量不需要标记lazy修饰符。

5. 类型属性

属于类型本身的属性叫做类型属性。这个属性只有一个拷贝，无论你创建了多少个类对应的实例。

注意: 不同于存储实例属性，你必须总是给存储类型属性一个默认值是因为类型本身不能拥有能够在初始化时给存储类型属性赋值的初始化器。
存储类型属性是在它们第一次访问时延迟初始化的。它们保证只会初始化一次，就算被多个线程同时访问，他们也不需要使用 lazy 修饰符标记。

类型属性语法

一般使用 static 关键字来表示类型属性。
对于类类型的计算类型属性，可以使用 class 关键字来允许子类重写父类的实现