1. WIKI教程
2. 学习swift
3. Swift - 属性( Properties)

Swift - 属性( Properties)

Swift 4语言为类，枚举或结构提供关联值的属性。 属性可以进一步分为存储属性和计算属性。

存储属性和计算属性之间的差异

存储的财产	计算财产
将常量和变量值存储为实例	计算值而不是存储值
由类和结构提供	由类，枚举和结构提供

Stored和Computed属性都与实例类型相关联。 当属性与其类型值相关联时，它将被定义为“类型属性”。 存储和计算属性通常与特定类型的实例相关联。 但是，属性也可以与类型本身相关联。 这些属性称为类型属性。 还使用了财产观察员

• 观察存储属性的值
• 观察从超类派生的继承子类的属性

存储属性

Swift 4引入了Stored Property概念来存储常量和变量的实例。 常量的存储属性由'let'关键字定义，变量的存储属性由'var'关键字定义。

• 在定义期间，存储属性提供“默认值”
• 在初始化期间，用户可以初始化和修改初始值

struct Number {
   var digits: Int
   let pi = 3.1415
}
var n = Number(digits: 12345)
n.digits = 67
print("\(n.digits)")
print("\(n.pi)")

当我们使用游乐场运行上述程序时，我们得到以下结果 -

67
3.1415

考虑上面代码中的以下行 -

let pi = 3.1415

这里，变量pi被初始化为具有实例pi = 3.1415的存储属性值。 因此，每当引用实例时，它将仅保持值3.1415。

存储属性的另一种方法是具有常量结构。 因此，结构的整个实例将被视为“常量的存储属性”。

struct Number {
   var digits: Int
   let numbers = 3.1415
}
var n = Number(digits: 12345)
n.digits = 67
print("\(n.digits)")
print("\(n.numbers)")
n.numbers = 8.7

当我们使用游乐场运行上述程序时，我们得到以下结果 -

error: cannot assign to 'numbers' in 'n'
n.numbers = 8.7

它不会将'number'重新初始化为8.7，而是返回一条错误消息，指示'number'被声明为常量。

懒惰的存储属性

Swift 4提供了一个名为“Lazy Stored Property”的灵活属性，它不会在第一次初始化变量时计算初始值。 在变量声明之前使用'lazy'修饰符将其作为惰性存储属性。

使用懒惰属性 -

• 延迟对象创建。
• 当属性依赖于类的其他部分时，尚未知道

class sample {
   lazy var no = number()    // `var` declaration is required.
}
class number {
   var name = "Swift 4"
}
var firstsample = sample()
print(firstsample.no.name)

当我们使用游乐场运行上述程序时，我们得到以下结果 -

Swift 4

实例变量

在Objective C中，Stored属性还有用于备份目的的实例变量，用于存储在stored属性中声明的值。

Swift 4将这两个概念集成到一个“存储属性”声明中。 而不是具有相应的实例变量和备份值“存储属性”包含通过变量名称，数据类型和内存管理功能在变量属性的单个位置中定义的所有集成信息。

计算属性

而不是存储值计算属性提供了getter和可选的setter来间接检索和设置其他属性和值。

class sample {
   var no1 = 0.0, no2 = 0.0
   var length = 300.0, breadth = 150.0
   var middle: (Double, Double) {
      get {
         return (length/2, breadth/2)
      }
      set(axis){
         no1 = axis.0 - (length/2)
         no2 = axis.1 - (breadth/2)
      }
   }
}
var result = sample()
print(result.middle)
result.middle = (0.0, 10.0)
print(result.no1)
print(result.no2)

当我们使用游乐场运行上述程序时，我们得到以下结果 -

(150.0, 75.0)
-150.0
-65.0

当computed属性将新值保留为undefined时，将为该特定变量设置默认值。

计算属性为只读属性

compute属性中的只读属性被定义为具有getter但没有setter的属性。 它始终用于返回值。 变量通过'。'进一步访问。 语法但不能设置为其他值。

class film {
   var head = ""
   var duration = 0.0
   var metaInfo: [String:String] {
      return [
         "head": self.head,
         "duration":"\(self.duration)"
      ]
   }
}
var movie = film()
movie.head = "Swift 4 Properties"
movie.duration = 3.09
print(movie.metaInfo["head"]!)
print(movie.metaInfo["duration"]!)

当我们使用游乐场运行上述程序时，我们得到以下结果 -

Swift 4 Properties
3.09

计算属性作为属性观察者

在Swift 4中观察和响应属性值使用Property Observers。 每次设置属性值时，都会调用属性观察者。 除了延迟存储的属性，我们可以通过方法'覆盖'将属性观察者添加到'inherited'属性。

属性观察者可以由任何一个来定义

• 在存储价值之前 - 意志

• 存储新值后 - 确定

• 在初始化程序集中设置属性时，无法调用didset观察者。

class Samplepgm {
   var counter: Int = 0 {
      willSet(newTotal){
         print("Total Counter is: \(newTotal)")
      }
      didSet {
         if counter > oldValue {
            print("Newly Added Counter \(counter - oldValue)")
         }
      }
   }
}
let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

当我们使用游乐场运行上述程序时，我们得到以下结果 -

Total Counter is: 100
Newly Added Counter 100
Total Counter is: 800
Newly Added Counter 700

本地和全局变量

声明本地和全局变量用于计算和观察属性。

局部变量	全局变量
在函数，方法或闭包上下文中定义的变量。	在函数，方法，闭包或类型上下文之外定义的变量。
用于存储和检索值。	用于存储和检索值。
存储的属性用于获取和设置值。	存储的属性用于获取和设置值。
还使用计算属性。	还使用计算属性。

输入属性

属性在类型定义部分中使用花括号{}定义，变量的范围也先前已定义。 为了定义值类型的类型属性，使用“static”关键字，对于类类型，使用“class”关键字。

语法 (Syntax)

struct Structname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // return an Int value here
   }
}
enum Enumname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // return an Int value here
   }
}
class Classname {
   class var computedTypeProperty: Int {
      // return an Int value here
   }
}

查询和设置属性

就像实例属性一样，查询类型属性并使用“。”进行设置。 单独使用类型语法而不是指向实例。

struct StudMarks {
   static let markCount = 97
   static var totalCount = 0
   var InternalMarks: Int = 0 {
      didSet {
         if InternalMarks > StudMarks.markCount {
            InternalMarks = StudMarks.markCount
         }
         if InternalMarks > StudMarks.totalCount {
            StudMarks.totalCount = InternalMarks
         }
      }
   }
}
var stud1Mark1 = StudMarks()
var stud1Mark2 = StudMarks()
stud1Mark1.InternalMarks = 98
print(stud1Mark1.InternalMarks)
stud1Mark2.InternalMarks = 87
print(stud1Mark2.InternalMarks)

当我们使用游乐场运行上述程序时，我们得到以下结果 -

97
87