【4858.com】事例代码,swift中的属性

By admin in 4858.com on 2019年4月15日

属性

苹果官方文书档案 Properties

苹果官方文书档案翻译 属性

性能能够将值与特定的类、结构体也许是枚举重联合会系起来。

一. 储存属性

仓库储存属性包蕴变量存储属性(由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不能够再赋新值,那也是常量属性和变量属性的根本差异。

性子能够将值与特定的类、结构体也许是枚举重联合会系起来。

本页内容囊括:

储存属性
测算属性
属性阅览器
全局变量和1部分变量
品种属性

性情的定义:性子将值跟特定的类、结构或枚举关联。存款和储蓄属性存款和储蓄常量或变量作为实例的壹有个别,总结属性总括(而不是储存)八个值。计算属性能够用来类、结构体和枚举里,存款和储蓄属性值只可以用于类和结构体。

仓库储存属性

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是一个常量结构体

【4858.com】事例代码,swift中的属性。小结:
由于结构体是值类型,当二个值类型的实例被标志为常量时,该实例的别样质量也均为常量。
而类是引用类型,给三个常量赋值引用类型实例,还是能修改10分实例的变量属性。

一、简介

1、存款和储蓄属性

即:存款和储蓄在一定类或结构体的实例里的三个常量或变量
//例子

struct LengthRanuge {
    var firstValue: Int
    let length: Int
}

var rangeOfThreeItems = LengthRanuge(firstValue: 0, length: 3)
该区间表示整数0,1,2
rangeOfThreeItems.firstValue = 6
该区间表示整数6,7,8
该结构体的实例包含一个名为firstValue的变量存储属性和一个名为length的常量存储属性。length在创建实例的时候被赋值,因为是一个常量存储属性,之后无法修改它的值。

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

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修饰符的性质同时被四个线程访问并且属性还尚无被开始化,则无从确定保证属性只初步化二回。

仓库储存属性算算属性的差异:

储存属性会储存敞亮或然变量作为实例的一片段,反之计量属性4858.com,会总结值(而不是存款和储蓄值)。
总结属性能够由类、结构体和枚举定义;储存属性唯其如此由类和布局体定义。

常量和储存属性

假诺制造二个结构体的实例并赋给了多少个常量,则无从修改实例内的别的性质,即便是变量存储属性

let rangeOfFourItems = LengthRanuge(firstValue: 0, length: 4)
//rangeOfFourItems.firstValue = 6  
//尽管firstValue是变量属性,这里也会报错

延迟储存属性

推迟囤积属性的开首值在其首先次利用时才开始展览测算。注明前标注 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"

二. 划算属性

计量属性并不存款和储蓄值,只提供八个读取器和二个可选的设置器来直接获得和装置其属性值。举个栗子:

// 结构体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))")
品类属性

与品种作者相关联的性质正是品种属性

推迟囤积属性

延期囤积属性是指第贰遍被调用的时候才会计算器开首值的习性。在性质证明前使用lazy来标记一个推迟存款和储蓄属性。必须将延迟存储属性声明为变量
//使用场地:当属性的值注重于在实例的组织进程截止前不能精通具体指的外表因素时,可能当属性的值须要复杂或大气计量时,能够只在急需的时候来计量它。
//例:

class DataImporter {
    /*
     DataImporter 是一个将外部文件中的数据导入的类
     这个类的初始化会消耗不少时间
     */
    var fileName = "data.txt"
    //这里提供数据导入功能
}

class DataManager {
    lazy var importer = DataImporter()
    var data = String()
    //这里提供数据管理功能
}

let manager = DataManager()
manager.data += "Some data"
manager.data += "Some more data"
//DataImporter 实例的 importer 属性还没有被创建

print(manager.importer.fileName)
//DataImporter 实例的 importer 属性现在才被创建了

储存属性与实例变量

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

二、个个击破

二、计算属性

测算属性不直接存款和储蓄值,而是提供多个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.init(x: 0.0, y: 0.0), size: Size(width: 10.0, height: 10.0))
let initialCenter = square.center
print(initialCenter.x, initialCenter.y)
square.center = Point(x: 15.0, y: 15.0)
print(square.center.x, square.center.y)

估测计算属性

4858.com 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)"

只读总计属性

2个有读取器但是并未有设置器的乘除属性正是所谓的只读计算属性。只读总计属性重返1个值,也足以经过点语法访问,不过无法被修改为另一个值。语法上,能够由此解除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来修饰,因为总结属性的值不明确。总结属性能够由类、结构体和枚举定义;存款和储蓄属性只可以由类和布局体定义。

一、存款和储蓄属性

正如暗中同意属性值中所述,你可感觉存款和储蓄属性提供2个暗中同意值作为它定义的一片段。你也得以在开始化的进度中装置和改造存款和储蓄属性的早先值。

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

FixedLengthRange 的实例有3个名称为 firstValue 的变量存款和储蓄属性和3个名为length 的常量存款和储蓄属性。在上头的例 子中,当新的值域成立时 length
已经被创制并且不可能再修改,因为那是叁个常量属性。

只读总计属性

唯有geter未有setter的乘除属性正是制度总计属性。只读计算属性总是回到二个值,能够经过点运算符来访问,但不能够安装新的值
只读总计属性的注明能够去掉get关键字

struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
        return width * height * depth
    }
}
let vol = Cuboid(width: 4, height: 7, depth: 6)
print(vol.volume)

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

三. 天性观看者

  • 属性旁观者会考查并对属性值的变型做出回答。
  • 可认为定义的轻巧存款和储蓄属性增加属性观看者,除了延迟存款和储蓄属性。
  • willSet在该值被积存在此之前被调用。 (默许参数名为newValue)
  • didSet在1个新值被积存后被调用。(默许参数名叫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
常量结构体实例的蕴藏属性

若是你创立了二个结构体的实例并且把那个实例赋给常量,你不可能修改那么些实例的质量,尽管是宣称为变量的性质:

1 let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
2 // this range represents integer values 0, 1, 2, and 3
3 rangeOfFourItems.firstValue = 6
4 // this will report an error, even though firstValue is a variable property

出于 rangeOfFourItems 被声称为常量(用 let 关键字),大家不可能改造其
firstValue 属性,纵然 firstValue 是1个 变量属性。
这是由于结构体是值类型。当3个值类型的实例被标记为常量时,该实例的其它属性也均为常量。

扩展:对于类来讲则不相同,它是引用类型。固然您给1个常量赋值引用类型实例,你照样能够修改十一分实例的变量属
性。*

三、属性监视器

定义:特性监视器监察和控制和响应属性值的退换,每一次属性棉被服装置值得时候都会被调用属性监视器。

增添属性监视器
willSet 在设置新的值以前调用
didSet 在新的值被设置之后随即调用
willSet会将新的属性值作为常量参数字传送入,在willSet的落实代码中可以为那个参数钦定3个称号,如若不钦赐则参数私下认可名字为newValue 表示
类似的,didSet 会将旧的属性值作为参数传入,能够命名或然接纳暗许参数名
oldValue

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 = 400

只读总结属性

八个有读取器不过尚未设置器的计量属性正是所谓的只读总计属性。

去掉 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"

四. 大局和一些变量

  • 全局变量是概念在别的函数、方法、闭包或然项目环境之外的变量。局地变量是概念在函数、方法恐怕闭包环境之中的变量。
  • 大局常量和变量长久是延迟总计的,与延迟存款和储蓄属性有着同样的作为。分裂于延迟存款和储蓄属性,全局常量和变量不须求标志lazy修饰符。
延迟囤积属性

延迟仓库储存属性的开头值在其首先次选拔时才起始猜测。你能够由此在其声称前标注lazy修饰语来代表贰个延迟存款和储蓄属性。

注意:你必须把延迟存款和储蓄属性申明为变量(使用var关键字),因为它的伊始值可能在实例早先化完毕以前不可能获取。敞亮属性则必须在开首化完毕此前有值,因而不可能声称为延迟。

肆、全局变量和一部分变量
  • 全局变量:是在函数,方法,闭包或任何项目之外定义的变量
  • 局地变量:是在函数,方法或闭包内部定义的变量
    PS:大局的常量或变量都以延迟计算的,跟延迟存款和储蓄属性相似,可是并非标准化识为lazy特性

质量观望者

属性观看者会调查并对属性值的变型做出回复。

  • 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

5. 门类属性

属于类型笔者的属性叫做类型属性。那些性格只有一个拷贝,无论你创设了多少个类对应的实例。

留神:
不一样于储存实例属性,你不能够不一而再给存款和储蓄类型属性一个默许值是因为项目作者不能够有所能够在起始化时给存款和储蓄类型属性赋值的开端化器。

存款和储蓄类型属性是在它们第三遍访问时延迟起始化的。它们保障只会初叶化2次,就算被四个线程同时做客,他们也不要求采用lazy 修饰符标志。

二、总结属性

除了存储属性,类、结构体和枚举也能够定义总计属性,而它其实并不存款和储蓄值。相反,他们提供一个读取器和三个可选的设置器来直接获得和设置任何的天性和值。

1  struct Point {
2      var x = 0.0, y = 0.0
3  }
4  struct Size {
5      var width = 0.0, height = 0.0
6  }
7  struct Rect {
8      var origin = Point()
9      var size = Size()
10     var center: Point {
11          get {
12              let centerX = origin.x + (size.width / 2)
13              let centerY = origin.y + (size.height / 2)
14              return Point(x: centerX, y: centerY)
15            }
16          set(newCenter) {
17          origin.x = newCenter.x - (size.width / 2)
18          origin.y = newCenter.y - (size.height / 2) 
19          }
20      }
21  }
22  var square = Rect(origin: Point(x: 0.0, y: 0.0)
23  size: Size(width: 10.0, height: 10.0))
24  let initialSquareCenter = square.center
25  square.center = Point(x: 15.0, y: 15.0)
26  print("square.origin is now at ( \(square.origin.x), \(square.origin.y))")
27  // prints "square.origin is now at (10.0, 10.0)"

注意:你无法不用 var
关键字定义总括属性——包含只读总结属性——为变量属性,因为它们的值不是原则性的。
let 关键字只用于常量属性,用于明显那多少个值借使作为实例开头化就不能够改造。

五、类型属性

选拔首要字static来定义类型属性。
在为类定义总结型类型属性时,能够改用关键字class来支撑子类对父类的落到实处进行重写。

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        //这里返回一个 Int 值
        return 9
    }
}

enum SomeEnumeration {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        //这里返回一个 Int 值
        return 8
    }
}

class SomeClass {
    static var storedTypeProperty = "Some value."
    class var computedTypeProperty: Int {
        return 7
    }
    class var overrideableComputedTypeProperty: Int {
        return 11
    }
}

全局变量和部分变量

算算属性和调查属性的本领一样对全局变量和1部分变量有效。

类型属性语法

  • 相似采纳 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
    }
}

留神:
上边的测算类型属性示例时对于只读计算类型属性的,但大家照旧得以动用与总括实例属性同样的语法定义可读写计算类型属性。

3、属性阅览者

性子观察者会和调查并对质量值得变化做出回复。每当贰个脾性的值棉被服装置时,属性阅览者都会被调用,即便那一个值与该属性当前的值一样。

你可以为你定义的专擅存储属性增加属性旁观者,除了延迟存款和储蓄属性。

您能够接纳将这个观望者或内部之一定义在品质上:

  • willSet 会在该值被贮存在此以前被调用。
  • didSet 会在3个新值被储存后被调用。

1经您兑现了二个 willSet
观察者,新的本性值会以常量格局参数字传送递。你能够在您的 willSet
达成中为这些参数定义名字。即使你未曾为它取名,那么它会使用暗许的名字
newValue 。
同等,假诺您兑现了多个didSet观察者,二个涵盖旧属性值的常量情势参数将会被传送。你可认为它定名,也可以应用暗许的款型参数名 oldValue 。若是你在性质自个儿的 didSet
观看者里给自身赋值,你赋值的新值就会代表 刚刚安装的值。

得到和装置类型属性的值

跟实例属性同样,类型属性也是通过点运算符来访问。但是,类型属性是经过项目作者来做客,而不是透过实例。
//如:

print(SomeStructure.storedTypeProperty)
print(SomeEnumeration.computedTypeProperty)
print(SomeClass.computedTypeProperty)

类型属性

可以定义属于类型作者的性质,不是那些类其余某2个实例的习性。那么些本性唯有三个正片,无论你创立了有点个类对应的实例。这样的属性叫做类型属性。
详见参考文书档案介绍。

询问和装置类型属性

行使点语法,但针对的指标是类而不是类的实例:

print(SomeStructure.storedTypeProperty)
// 结果为: "Some value."
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
// 结果为: "Another value."
print(SomeEnumeration.computedTypeProperty)
// 结果为: "6"
print(SomeClass.computedTypeProperty)
// 结果为: "27"
四、全局和一部分变量

下面描述的推测属性和侦察属性的力量同样对全局变量和1部分变量有效。全局变量是概念在任何函数、方法、闭
包大概项目环境之外的变量。局地变量是概念在函数、方法照旧闭包环境之中的变量。
您在以前章节中所蒙受的全局和有个别变量都是储存变量。存款和储蓄变量,类似于储存属性,为一定类型的值提供仓库储存并且同意这么些值被设置和取回。
一言以蔽之,你一样能够定义总括属性以及给存款和储蓄变量定义观看者,无论是全局照旧有些环境。总计变量总结而不是存款和储蓄值,并且与计量属性的写法一致。

注意
全局敞亮和变量恒久是延迟总括的,与延迟存款和储蓄属性有着同样的一坐一起。分歧于延迟存款和储蓄属性,全局常量和变量不须求标识lazy 修饰符。

类型属性语法

static 关键字来开1品类属性

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
    }
}
五、类型属性

您一样能够定义属于类型小编的天性,不是其壹类型的某贰个实例的属性。那脾本性只有3个拷贝,无论你创建了稍稍个类对应的实例。那样的性质叫做项目属性
存款和储蓄类型属性能够是变量大概常量。总括类型属性总要被声称为变量属性,与计量实例属性壹致。

注意:壹.不相同于存款和储蓄实例属性,你不可能不延续给存款和储蓄类型属性三个暗许值。那是因为项目笔者无法具备能够在
开始化时给存款和储蓄类型属性赋值的开始化器。
贰.存款和储蓄类型属性是在它们第一遍访问时延迟初叶化的。它们保障只会起初化三回,尽管被多个线程同
时造访,他们也不要求采纳 lazy 修饰符标志。

花色属性在类里询问和安装,而不是这几个类别的实例

查询和设置类型属性

品种属性在类里询问和设置,而不是以此类其他实例。

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"

接下去的事例使用了两个存款和储蓄类型属性作为建立模型1个为数字音频信道音频衡量表的结构体的一片段。每三个频段都有二个在乎
0 到 10 之间的数字音频等第。

上面包车型客车图例呈现了这一个节奏频道如何结合建立模型贰个立体声音频度量表。当频道的点子电平为
0,那多少个对应频道的灯就不会亮。当电平是 10,全部这些频道的灯都会亮。在那一个图例里,左声道当前电平是 9,右声道的脚下电平是 柒 :

4858.com 2

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

var leftChannel = AudioChannel()
var rightChannel = AudioChannel()

leftChannel.currentLevel = 7
print(leftChannel.currentLevel)
// prints "7"
print(AudioChannel.maxInputLevelForAllChannels)
// prints "7"

rightChannel.currentLevel = 11
print(rightChannel.currentLevel)
// prints "10"
print(AudioChannel.maxInputLevelForAllChannels)
// prints "10"

完结!!!

发表评论

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

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有