La déclaration et la fonction des propriétés dans Swift

1. Introduction

Les attributs associent des valeurs à des classes, des structures et des énumérations. Les propriétés dans Swift sont divisées en deux types : les propriétés stockées et les propriétés calculées. Les propriétés stockées sont utilisées pour stocker une valeur et ne peuvent être utilisées que pour les classes et les structures. Les propriétés calculées sont utilisées pour calculer une valeur et peuvent être utilisées pour les classes, les structures et les structures. énumérations.

2. Attributs de stockage

Les attributs de stockage utilisent des variables ou des constantes pour stocker une valeur Lorsque vous déclarez un attribut de stockage, vous pouvez lui définir une valeur par défaut, ou vous-même. can L'exemple de construction consiste à définir la valeur. Les attributs sont accessibles via la syntaxe par points. L'exemple de code pour les attributs stockés de la structure est le suivant :

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

<🎜. >

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

3. Propriétés calculées

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)

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

Les propriétés calculées en lecture seule peuvent être encore abrégées. Comme il n'y a pas de bloc de code défini, le mot-clé get et les parenthèses peuvent également être omis sans provoquer d'ambiguïté :

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

Les méthodes get et set dans les propriétés calculées dans Swift et les méthodes get et set dans Objective-C sont en fait Ce n'est pas la même chose. Objective-C fournit des méthodes set et get qui permettent aux développeurs d'effectuer certaines opérations personnalisées lorsque les propriétés sont sur le point d'être obtenues ou définies. Cette partie des besoins de développement est implémentée dans Swift via des écouteurs de propriétés.

Il existe deux types d'écouteurs d'attribut, willSet et didSet. willSet est exécuté lorsque la valeur de l'attribut est sur le point de changer, et didSet est exécuté lorsque la valeur de l'attribut a changé, et les valeurs avant et après le le changement est transmis. Un exemple est le suivant :

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 générera un paramètre nommé newValue par défaut, et didSet générera un paramètre nommé oldValue par défaut. Personnalisez également le nom de ces paramètres, les exemples sont les suivants :

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

Les propriétés d'instance sont spécifiques aux instances d'un type, tandis que les propriétés de type sont spécifiques au type. Chaque fois qu'une paire de types est instanciée, son instance possède un ensemble indépendant de propriétés d'instance et les propriétés de type sont partagées par toutes les instances de la classe. En Objective-C, les propriétés globales sont généralement utilisées pour obtenir cet effet. utilisez le mot-clé static pour déclarer les attributs de type. L'exemple est le suivant :

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)

Notez qu'il existe un cas particulier où le type calcule les attributs d'un class sont , si cela nécessite un héritage et une réécriture par sous-classes, le mot-clé static doit être remplacé par le mot-clé class L'exemple est le suivant :

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