Swift - Eigenschaften

Die Sprache Swift 4 bietet Eigenschaften für Klasse, Aufzählung oder Struktur, um Werte zuzuordnen. Eigenschaften können weiter in gespeicherte Eigenschaften und berechnete Eigenschaften klassifiziert werden.

Unterschied zwischen gespeicherten Eigenschaften und berechneten Eigenschaften

Gespeichertes Eigentum	Berechnete Eigenschaft
Speichern Sie konstante und variable Werte als Instanz	Berechnen Sie einen Wert, anstatt den Wert zu speichern
Bereitgestellt von Klassen und Strukturen	Bereitgestellt durch Klassen, Aufzählungen und Strukturen

Sowohl gespeicherte als auch berechnete Eigenschaften sind dem Instanztyp zugeordnet. Wenn die Eigenschaften mit ihren Typwerten verknüpft sind, wird sie als "Typeneigenschaften" definiert. Gespeicherte und berechnete Eigenschaften sind normalerweise Instanzen eines bestimmten Typs zugeordnet. Eigenschaften können jedoch auch dem Typ selbst zugeordnet werden. Solche Eigenschaften sind als Typeneigenschaften bekannt. Immobilienbeobachter werden ebenfalls eingesetzt

Um den Wert der gespeicherten Eigenschaften zu beobachten
Beobachtung der Eigenschaft der von der Oberklasse abgeleiteten geerbten Unterklasse

Gespeicherte Eigenschaften

Swift 4 führt das Konzept der gespeicherten Eigenschaften ein, um die Instanzen von Konstanten und Variablen zu speichern. Gespeicherte Eigenschaften von Konstanten werden durch das Schlüsselwort 'let' definiert, und gespeicherte Eigenschaften von Variablen werden durch das Schlüsselwort 'var' definiert.

Während der Definition Die gespeicherte Eigenschaft liefert den Standardwert.
Während der Initialisierung kann der Benutzer die Anfangswerte initialisieren und ändern

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

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

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

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

67
3.1415

Betrachten Sie die folgende Zeile im obigen Code -

let pi = 3.1415

Hier wird die Variable pi als gespeicherter Eigenschaftswert mit der Instanz pi = 3.1415 initialisiert. Wenn also die Instanz verwiesen wird, enthält sie nur den Wert 3.1415.

Eine andere Methode, um gespeicherte Eigenschaften zu haben, besteht darin, konstante Strukturen zu haben. Daher wird die gesamte Instanz der Strukturen als "gespeicherte Eigenschaften von Konstanten" betrachtet.

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

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

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

Anstatt die 'Nummer' auf 8.7 neu zu initialisieren, wird eine Fehlermeldung zurückgegeben, die angibt, dass die 'Nummer' als konstant deklariert ist.

Lazy Stored Property

Swift 4 bietet eine flexible Eigenschaft namens "Lazy Stored Property", bei der die Anfangswerte nicht berechnet werden, wenn die Variable zum ersten Mal initialisiert wird. Der Modifikator 'faul' wird vor der Variablendeklaration verwendet, um ihn als faul gespeicherte Eigenschaft zu haben.

Lazy Properties werden verwendet -

Um die Objekterstellung zu verzögern.
Wenn die Eigenschaft von anderen Teilen einer Klasse abhängig ist, sind diese noch nicht bekannt

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

class number {
   var name = "Swift 4"
}

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

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

Swift 4

Instanzvariablen

In Ziel C verfügen gespeicherte Eigenschaften auch über Instanzvariablen zu Sicherungszwecken, um die in gespeicherten Eigenschaften deklarierten Werte zu speichern.

Swift 4 integriert diese beiden Konzepte in eine einzige Deklaration für gespeicherte Eigenschaften. Anstatt eine entsprechende Instanzvariable und einen Sicherungswert zu haben, enthält 'gespeicherte Eigenschaft' alle integrierten Informationen, die an einem einzigen Ort über die Variableneigenschaft nach Variablenname, Datentyp und Speicherverwaltungsfunktionen definiert sind.

Berechnete Eigenschaften

Anstatt die berechneten Werte zu speichern, stellen Sie einen Getter und einen optionalen Setter bereit, um andere Eigenschaften und Werte indirekt abzurufen und festzulegen.

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)

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

(150.0, 75.0)
-150.0
-65.0

Wenn eine berechnete Eigenschaft den neuen Wert als undefiniert belässt, wird der Standardwert für diese bestimmte Variable festgelegt.

Berechnete Eigenschaften als schreibgeschützte Eigenschaften

Eine schreibgeschützte Eigenschaft in einer berechneten Eigenschaft wird als eine Eigenschaft mit Getter, aber ohne Setter definiert. Es wird immer verwendet, um einen Wert zurückzugeben. Auf die Variablen wird weiter über ein '.' Syntax kann aber nicht auf einen anderen Wert gesetzt werden.

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

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

Swift 4 Properties
3.09

Berechnete Eigenschaften als Eigenschaftsbeobachter

In Swift 4 werden Eigenschaftsbeobachter verwendet, um Eigenschaftswerte zu beobachten und darauf zu reagieren. Jedes Mal, wenn Eigenschaftswerte festgelegt werden, werden Eigenschaftsbeobachter aufgerufen. Mit Ausnahme von verzögert gespeicherten Eigenschaften können wir der 'geerbten' Eigenschaft durch die Methode 'Überschreiben' Eigenschaftsbeobachter hinzufügen.

Eigenschaftsbeobachter können entweder definiert werden

Vor dem Speichern des Wertes - willset
Nach dem Speichern des neuen Wertes - didset
Wenn eine Eigenschaft in einem Initialisierer festgelegt wird, können Willens- und Didset-Beobachter nicht aufgerufen werden.

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

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

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

Lokale und globale Variablen

Lokale und globale Variablen werden zum Berechnen und Beobachten der Eigenschaften deklariert.

Lokale Variablen	Globale Variablen
Variablen, die in einem Funktions-, Methoden- oder Abschlusskontext definiert sind.	Variablen, die außerhalb des Funktions-, Methoden-, Abschluss- oder Typkontexts definiert sind.
Wird zum Speichern und Abrufen von Werten verwendet.	Wird zum Speichern und Abrufen von Werten verwendet.
Gespeicherte Eigenschaften werden verwendet, um die Werte abzurufen und festzulegen.	Gespeicherte Eigenschaften werden verwendet, um die Werte abzurufen und festzulegen.
Berechnete Eigenschaften werden ebenfalls verwendet.	Berechnete Eigenschaften werden ebenfalls verwendet.

Typ Eigenschaften

Die Eigenschaften werden im Abschnitt Typdefinition mit geschweiften Klammern {} definiert, und der Umfang der Variablen wurde ebenfalls zuvor definiert. Zum Definieren von Typeneigenschaften für Werttypen wird das Schlüsselwort 'static' und für Klassentypen das Schlüsselwort 'class' verwendet.

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

Eigenschaften abfragen und einstellen

Genau wie Instanzeigenschaften werden Typeneigenschaften abgefragt und mit '.' Syntax nur für den Typ, anstatt auf die Instanz zu verweisen.

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)

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

97
87