Swift - Propriétés

Le langage Swift 4 fournit des propriétés de classe, d'énumération ou de structure pour associer des valeurs. Les propriétés peuvent être classées en propriétés stockées et propriétés calculées.

Différence entre les propriétés stockées et les propriétés calculées

Propriété stockée	Propriété calculée
Stocker les valeurs constantes et variables comme instance	Calculer une valeur plutôt que stocker la valeur
Fourni par les classes et les structures	Fourni par des classes, des énumérations et des structures

Les propriétés stockées et calculées sont associées au type d'instance. Lorsque les propriétés sont associées à ses valeurs de type, elles sont définies comme «Propriétés de type». Les propriétés stockées et calculées sont généralement associées à des instances d'un type particulier. Cependant, les propriétés peuvent également être associées au type lui-même. Ces propriétés sont appelées propriétés de type. Des observateurs de propriété sont également utilisés

Pour observer la valeur des propriétés stockées
Pour observer la propriété de la sous-classe héritée dérivée de la superclasse

Propriétés stockées

Swift 4 introduit le concept de propriété stockée pour stocker les instances de constantes et de variables. Les propriétés stockées des constantes sont définies par le mot clé 'let' et les propriétés stockées des variables sont définies par le mot clé 'var'.

Pendant la définition, la propriété stockée fournit la «valeur par défaut»
Lors de l'initialisation, l'utilisateur peut initialiser et modifier les valeurs initiales

struct Number {
   var digits: Int
   let pi = 3.1415
}

var n = Number(digits: 12345)
n.digits = 67

print("\(n.digits)")
print("\(n.pi)")

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

67
3.1415

Considérez la ligne suivante dans le code ci-dessus -

let pi = 3.1415

Ici, la variable pi est initialisée en tant que valeur de propriété stockée avec l'instance pi = 3.1415. Ainsi, chaque fois que l'instance est référencée, elle contiendra la valeur 3.1415 seule.

Une autre méthode pour avoir une propriété stockée est d'avoir des structures constantes. Ainsi, toute l'instance des structures sera considérée comme «Propriétés stockées des constantes».

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

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

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

Au lieu de réinitialiser le «nombre» à 8,7, il renverra un message d'erreur indiquant que le «nombre» est déclaré comme constant.

Propriété stockée paresseuse

Swift 4 fournit une propriété flexible appelée «Lazy Stored Property» où il ne calculera pas les valeurs initiales lorsque la variable est initialisée pour la première fois. Le modificateur 'lazy' est utilisé avant la déclaration de variable pour l'avoir comme propriété stockée différée.

Les propriétés paresseuses sont utilisées -

Pour retarder la création d'objet.
Lorsque la propriété dépend d'autres parties d'une classe, qui ne sont pas encore connues

class sample {
   lazy var no = number()    // `var` declaration is required.
}

class number {
   var name = "Swift 4"
}

var firstsample = sample()
print(firstsample.no.name)

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Swift 4

Variables d'instance

En Objective C, les propriétés stockées ont également des variables d'instance à des fins de sauvegarde pour stocker les valeurs déclarées dans la propriété stockée.

Swift 4 intègre ces deux concepts dans une seule déclaration de «propriété stockée». Au lieu d'avoir une variable d'instance correspondante et une valeur de sauvegarde, la «propriété stockée» contient toutes les informations intégrées définies dans un seul emplacement sur la propriété des variables par nom de variable, type de données et fonctionnalités de gestion de la mémoire.

Propriétés calculées

Plutôt que de stocker les valeurs calculées, les propriétés fournissent un getter et un setter facultatif pour récupérer et définir indirectement d'autres propriétés et valeurs.

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)

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

(150.0, 75.0)
-150.0
-65.0

Lorsqu'une propriété calculée a laissé la nouvelle valeur non définie, la valeur par défaut sera définie pour cette variable particulière.

Propriétés calculées en tant que propriétés en lecture seule

Une propriété en lecture seule dans une propriété calculée est définie comme une propriété avec getter mais sans setter. Il est toujours utilisé pour renvoyer une valeur. Les variables sont ensuite accessibles via un '.' Syntaxe mais ne peut pas être définie sur une autre valeur.

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"]!)

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Swift 4 Properties
3.09

Propriétés calculées en tant qu'observateurs de propriétés

Dans Swift 4 pour observer et répondre aux valeurs de propriété, des observateurs de propriété sont utilisés. Chaque fois que les valeurs de propriété sont définies, des observateurs de propriété sont appelés. Sauf les propriétés stockées paresseuses, nous pouvons ajouter des observateurs de propriété à la propriété «héritée» par la méthode «remplacement».

Les observateurs de propriétés peuvent être définis soit par

Avant de stocker la valeur - willset
Après avoir enregistré la nouvelle valeur - didset
Lorsqu'une propriété est définie dans un initialiseur, les observateurs willset et didset ne peuvent pas être appelés.

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

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

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

Variables locales et globales

Les variables locales et globales sont déclarées pour le calcul et l'observation des propriétés.

Variables locales	Variables globales
Variables définies dans une fonction, une méthode ou un contexte de fermeture.	Variables définies en dehors du contexte de fonction, de méthode, de fermeture ou de type.
Utilisé pour stocker et récupérer des valeurs.	Utilisé pour stocker et récupérer des valeurs.
Les propriétés stockées sont utilisées pour obtenir et définir les valeurs.	Les propriétés stockées sont utilisées pour obtenir et définir les valeurs.
Les propriétés calculées sont également utilisées.	Les propriétés calculées sont également utilisées.

Type de propriétés

Les propriétés sont définies dans la section Définition de type avec des accolades {} et la portée des variables est également définie précédemment. Pour définir les propriétés de type pour les types de valeur, le mot clé «static» est utilisé et pour les types de classe, le mot clé «class» est utilisé.

Syntaxe

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

Interroger et définir les propriétés

Tout comme les propriétés d'occurrence Les propriétés de type sont interrogées et définies avec '.' Syntaxe uniquement sur le type au lieu de pointer vers l'instance.

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)

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

97
87