Die Deklaration und Funktion von Eigenschaften in Swift

1. Einführung

Attribute verknüpfen Werte mit Klassen, Strukturen und Aufzählungen. Eigenschaften werden in Swift in zwei Typen unterteilt: gespeicherte Eigenschaften und berechnete Eigenschaften. Gespeicherte Eigenschaften werden zum Speichern eines Werts verwendet und können nur für Klassen und Strukturen verwendet werden. Berechnete Eigenschaften werden zum Berechnen eines Werts verwendet und können für Klassen, Strukturen usw. verwendet werden Aufzählungen.

2. Speicherattribute

Speicherattribute verwenden Variablen oder Konstanten, um einen Wert zu speichern. Sie können einen Standardwert dafür festlegen can Das Konstruktionsbeispiel besteht darin, auf die Attribute über die Punktsyntax zuzugreifen. Der Beispielcode für die gespeicherten Attribute der Struktur lautet wie folgt:

struct MyStruct {
  var property1 = 1
  var property2:Int
}
var obj = MyStruct(property1: 1, property2: 2)
//通过点语法进行属性的访问
print(obj.property1,obj.property2)

Die obige Struktur: Wenn eine Eigenschaft als Let-Konstante deklariert ist, kann diese Eigenschaft nicht geändert werden. Beachten Sie außerdem, dass die Eigenschaften in der Struktur nicht geändert werden können, selbst wenn es sich um Variablen handelt, wenn Sie let beim Erstellen einer Instanz einer Struktur verwenden. Das unterscheidet sich stark vom Unterricht.

Es gibt auch eine Art von Speicherattribut, das als verzögertes Speicherattribut bezeichnet wird. Sie können sich eine Situation vorstellen, in der einige Attribute einer Klasse möglicherweise nicht nach jeder Instanz der Klasse verwendet werden und die Konstruktion einiger Attribute möglicherweise A verbraucht Ein intelligentes Design besteht zu diesem Zeitpunkt darin, dass dieser Attributtyp nicht erstellt wird. Wenn eine Instanz der Unterklasse dieses Attribut verwendet, wird ein solches Attribut als verzögert bezeichnet storage-Attribut und wird mit dem Schlüsselwort lazy deklariert:

//第一个类
class MyClass1 {
  init(){
    print("MyClass1类被构造")
  }
}
class MyClass2 {
  //声明为延时存储属性
  lazy var body = MyClass1()
}
//在构造MyClass2时 并不会进行body属性的构造 不会有打印信息
var obj2 = MyClass2()
//执行下面代码后 会有打印信息 使用body属性使得body被构造
obj2.body

Beachten Sie, dass die Eigenschaften vorliegen, wenn die verzögerte Konstruktion in mehreren Threads ausgeführt wird verwendet werden und es gibt keine Garantie dafür, dass sie nur einmal gebaut werden.

3. Berechnete Eigenschaften

Ein einfaches Verständnis ist, dass berechnete Eigenschaften keine unabhängigen Eigenschaften sind, die zum Speichern von Werten verwendet werden wird hauptsächlich verwendet, um den Wert anderer gespeicherter Eigenschaften durch Berechnung zu ermitteln oder festzulegen. Ein Beispiel lautet wie folgt:

struct Circle {
  //圆心
  var center:(Double,Double)
  //半径
  var r:Double
  //周长 将其作为计算属性
  var l:Double{
    get{
      //计算圆的周长
      return 2.0*r*M_PI
    }
    set{
      //通过周长重新计算半径 默认传入的参数名为newValue
      r = newValue/(M_PI*2)
    }
  }
}
var circle = Circle(center: (0,0), r: 2)
print(circle.l)
circle.l=24
print(circle.r)

Wie aus dem obigen Demonstrationscode hervorgeht, ist das l-Attribut kein neues Attribut, sondern l wird berechnet Über das r-Attribut können Sie auch auf r schließen. Beachten Sie, dass im berechneten Attribut zwei Codeblöcke erstellt werden können. Der set-Codeblock ist standardmäßig generiert Um die von außen übergebenen Daten zu übergeben, muss der Get-Code-Block natürlich auch nur implementiert werden. In diesem Fall handelt es sich um eine schreibgeschützte berechnete Eigenschaft, die nur abgerufen werden kann und kann nicht eingestellt werden. Zu beachten ist außerdem, dass Entwickler auch einen Parameternamen nach dem festgelegten Codeblock anpassen können, um von außen übergebene Parameter zu empfangen. Das Beispiel lautet wie folgt:

struct Circle {
  //圆心
  var center:(Double,Double)
  //半径
  var r:Double
  //周长 将其作为计算属性
  var l:Double{
    get{
      //计算圆的周长
      return 2.0*r*M_PI
    }
    set(newL){
      //通过周长重新计算半径 默认传入的参数名为newValue
      r = newL/(M_PI*2)
    }
  }
}

Schreibgeschützte berechnete Eigenschaften können weiter abgekürzt werden, sodass das Schlüsselwort get und Klammern auch weggelassen werden können, ohne dass es zu Mehrdeutigkeiten kommt:

struct Point {
  var x:Double
  var y:Double
  var center:(Double,Double){
    return (x/2,y/2)
  }
}

4. Property-Listener

Die Get- und Set-Methoden in berechneten Eigenschaften in Swift und die Get- und Set-Methoden in Objective-C sind tatsächlich Es ist nicht dasselbe. Objective-C bietet Set- und Get-Methoden, mit denen Entwickler einige benutzerdefinierte Vorgänge ausführen können, wenn Eigenschaften abgerufen oder festgelegt werden sollen. Dieser Teil der Entwicklungsanforderungen wird in Swift über Eigenschafts-Listener implementiert.

Es gibt zwei Arten von Attribut-Listenern: willSet und didSet. WillSet wird ausgeführt, wenn sich der Attributwert ändern wird, und didSet wird ausgeführt, wenn sich der Attributwert geändert hat Änderungen werden übernommen. Ein Beispiel lautet wie folgt:

struct Point {
  var x:Double
  var y:Double{
    willSet{
      print("将要进行值的更新设置,新的值是:",newValue)
    }
    didSet{
      print("已经进行值得更新设置,旧的值是:",oldValue)
    }
  }
  var center:(Double,Double){
    return (x/2,y/2)
  }
}
var point = Point(x: 3, y: 3)
//将打印
/*
 将要进行值的更新设置,新的值是: 4.0
 已经进行值得更新设置,旧的值是: 3.0
 */
point.y=4

WillSet generiert standardmäßig einen Parameter mit dem Namen newValue und didSet generiert standardmäßig einen Parameter mit dem Namen oldValue Passen Sie auch die Benennung dieser Parameter an. Beispiele sind wie folgt:

struct Point {
  var x:Double
  var y:Double{
    willSet(new){
      print("将要进行值的更新设置,新的值是:",new)
    }
    didSet(old){
      print("已经进行值得更新设置,旧的值是:",old)
    }
  }
  var center:(Double,Double){
    return (x/2,y/2)
  }
}

5. Instanzattribute und Typattribute

Instanzeigenschaften sind spezifisch für Instanzen eines Typs, während Typeigenschaften spezifisch für den Typ sind. Jedes Mal, wenn ein Typpaar instanziiert wird, verfügt seine Instanz über einen unabhängigen Satz von Instanzeigenschaften, und die Typeigenschaften werden von allen Instanzen der Klasse gemeinsam genutzt. In Objective-C werden normalerweise globale Eigenschaften verwendet, um diesen Effekt zu erzielen. Verwenden Sie das Schlüsselwort static, um Typattribute zu deklarieren:

struct Point {
  //类型存储属性
  static var name:String = "Point"
  //类型计算属性
  static var subName:String{
    return "sub"+name
  }
  var x:Double
  var y:Double{
    willSet(new){
      print("将要进行值的更新设置,新的值是:",new)
    }
    didSet(old){
      print("已经进行值得更新设置,旧的值是:",old)
    }
  }
  var center:(Double,Double){
    return (x/2,y/2)
  }
}
//类型属性 通过类型点语法来获取
print(Point.name,Point.subName)

Beachten Sie, dass es einen Sonderfall für die Berechnung von Attributen von Klassentypen gibt. Wenn eine Vererbung und Umschreibung durch Unterklassen erforderlich ist, muss das Schlüsselwort static durch das Schlüsselwort class ersetzt werden. Das Beispiel lautet wie folgt:

class SomeClass {
  static var storedTypeProperty = "Some value."
  static var computedTypeProperty: Int {
    return 27
  }
  //支持子类进行重写的计算属性
  class var overrideableComputedTypeProperty: Int {
    return 107
  }
}

Weitere Artikel zur Deklaration und Funktion von Attributen in Swift finden Sie auf der chinesischen PHP-Website!