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)

La structure ci-dessus, si une propriété est déclarée comme constante let, cette propriété ne peut pas être modifiée. Une autre chose à noter est que si vous utilisez let lors de la création d'une instance d'une structure, les propriétés de la structure ne peuvent pas être modifiées même si ce sont des variables. C'est très différent des cours.

Il existe également un type d'attribut de stockage appelé attribut de stockage retardé. Vous pouvez imaginer une situation dans laquelle certains attributs d'une classe peuvent ne pas être utilisés après chaque instance de la classe, et la construction de certains attributs peut consommer A. Beaucoup de temps, une conception intelligente à l'heure actuelle est que ce type d'attribut n'est pas construit lorsque la classe est instanciée. Lorsqu'une instance de la sous-classe utilise cet attribut, cet attribut est construit. C'est ce qu'on appelle le stockage différé. attribut et est déclaré à l'aide du mot-clé lazy. L'exemple est le suivant :

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

Notez que si la construction retardée est effectuée dans plusieurs threads, les propriétés sont utilisées. et rien ne garantit qu'ils ne seront construits qu'une seule fois.

3. Propriétés calculées

Une compréhension simple est que les propriétés calculées ne sont pas des propriétés indépendantes utilisées pour stocker des valeurs, ce qui est une méthode de calcul. est principalement utilisé pour obtenir ou définir la valeur d'autres propriétés stockées par calcul. Un exemple est le suivant :

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)

Comme le montre le code de démonstration ci-dessus, l'attribut l n'est pas un nouvel attribut, mais l est calculé via l'attribut r. Ou utilisez l pour déduire r. Une chose à noter est que deux blocs de code, set et get, peuvent être créés dans l'attribut calculé. Le bloc de code set est facultatif et un paramètre newValue sera généré par défaut. pour transmettre les données transmises de l'extérieur. Le bloc de code get doit être implémenté. Bien entendu, vous ne pouvez également implémenter que le bloc de code get. Dans ce cas, cette propriété sera une propriété calculée en lecture seule qui ne peut être obtenue. et ne peut pas être réglé. Une autre chose à noter est que les développeurs peuvent également personnaliser un nom de paramètre après le bloc de code défini pour recevoir les paramètres transmis de l'extérieur. L'exemple est le suivant :

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

4. Écouteur de propriété

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

5. Attributs d'instance et attributs de type

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

Pour plus d'articles liés à la déclaration et à la fonction des attributs dans Swift, veuillez faire attention au site Web PHP chinois !