【澳门新葡亰平台官网】例子代码

属性

苹果官方文档 Properties

苹果官方文档翻译 属性

属性可以将值与特定的类、结构体或者是枚举联系起来。

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不能再赋新值,这也是常量属性和变量属性的根本区别。

存储属性

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

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

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

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

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

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

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 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修饰符的属性同时被多个线程访问并且属性还没有被初始化,则无法保证属性只初始化一次。

延迟储存属性

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

class DataImporter {

    //DataImporter is a class to import data from an external file.
    //The class is assumed to take a non-trivial 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

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

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))")

储存属性与实例变量

Swift 属性没有与之相对应的实例变量,并且属性的后备存储不能被直接访问。

简写设置器(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)
        }
    }
}

计算属性

澳门新葡亰平台官网 1

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)"

只读计算属性

一个有读取器但是没有设置器的计算属性就是所谓的只读计算属性。只读计算属性返回一个值,也可以通过点语法访问,但是不能被修改为另一个值。语法上,可以通过去掉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来修饰,因为计算属性的值不确定。计算属性可以由类、结构体和枚举定义;存储属性只能由类和结构体定义。

简写设置器(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 {
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.y - (size.height / 2)
        }
    }
}

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

发表评论

电子邮件地址不会被公开。 必填项已用*标注