In swift werden Eigenschaften verwendet, um Attribute eines Objekts zu beschreiben und diese können Konstanten oder Variablen in Klassen, Strukturen oder Aufzählungen sein.
In swift werden Eigenschaften verwendet, um die Werte für Klassen, Strukturen oder Aufzählungen zu speichern, und Eigenschaften haben Getter- und Setter-Methoden, um die Eigenschaftswerte je nach Bedarf zu ändern oder zu setzen.
- Swift Define a Property
- Eigenschaften schnell zuweisen und zugreifen
- Swift Gespeicherte Eigenschaften
- Gespeicherte Eigenschaften für konstante Strukturinstanzen
- Swift Lazy Stored Properties
- Swift Computed Properties
- Swift Read-Only Computed Properties
- Swift Property Observer
- Swift Type Property
- Swift Abfragen und Setzen von Typeigenschaften
Swift Define a Property
Nachfolgend ein einfaches Beispiel für die Erstellung einer Klasse mit Eigenschaften in der Programmiersprache swift.
class UserDetails {
var firstName: String = „“
var lastName: String = „“
}
Wenn Sie das obige Beispiel betrachten, haben wir eine Klasse „UserDetails“ mit zwei Eigenschaften (firstName, lastName) definiert.
Eigenschaften schnell zuweisen und zugreifen
Nachfolgend ein Beispiel für das Deklarieren und Zuweisen von Werten zu den definierten Eigenschaften in der Klasse.
class UserDetails {
var firstName: String = „“
var lastName: String = „“
}
var uinfo = UserDetails()
uinfo.firstName = „Suresh“
uinfo.lastName = „Dasari“
print(„Name: \( uinfo.firstName) \(uinfo.lastName)“)
Wenn Sie das obige Beispiel betrachten, haben wir zwei Eigenschaften „firstName“ und „lastName“ definiert, und diese Werte sind mit der Klasse „UserDetails“ verbunden. Danach haben wir eine Instanz für diese Klasse erstellt und auf die Eigenschaften innerhalb der Klasse zugegriffen, um Werte basierend auf unseren Anforderungen zuzuweisen.
Wenn wir das obige Programm in Swift Playground ausführen, erhalten wir ein Ergebnis wie unten gezeigt
Auf die gleiche Weise können wir in der Programmiersprache Swift Eigenschaften in Strukturen und Aufzählungen definieren und darauf zugreifen.
Wir haben verschiedene Arten von Eigenschaften in der Swift-Programmiersprache zur Verfügung, nämlich
- Gespeicherte Eigenschaften
- Berechnete Eigenschaften
Swift Gespeicherte Eigenschaften
In Swift ist eine gespeicherte Eigenschaft eine Konstante oder Variable und wird als Teil einer Instanz einer bestimmten Klasse oder Struktur gespeichert. Die gespeicherte Eigenschaft kann verwendet werden, um eine Variable mit dem Schlüsselwort var und eine Konstante mit dem Schlüsselwort let zu speichern.
Wir können einen Standardwert für eine gespeicherte Eigenschaft als Teil ihrer Definition bereitstellen und wir können die Anfangswerte einer gespeicherten Eigenschaft während ihrer Initialisierung ändern.
Nun werden wir sehen, wie man gespeicherte Eigenschaften in Klassen definiert und wie man die anfänglichen Werte von gespeicherten Eigenschaften während der Initialisierung mit einem Beispiel ändert.
Nachfolgend ein Beispiel für die Definition von gespeicherten Eigenschaften als Teil einer Klasse oder Struktur in einer Swift-Programmiersprache.
struct UserDetails {
var firstName: String = „Rohini“
let lastName: String
}
var uinfo = UserDetails(firstName: „Suresh“, lastName: “ Dasari“)
print(„Name: \( uinfo.firstName) \(uinfo.lastName)“)
Wenn Sie das obige Beispiel betrachten, haben wir zwei gespeicherte Eigenschaften (firstName, lastName) definiert, eine als Variable (var) und eine andere als Konstante (let) mit Initialwerten. Danach haben wir eine Instanz der Struktur erstellt und die Anfangswerte während der Initialisierung geändert.
Wenn wir das obige Programm in Swift Playground ausführen, erhalten wir ein Ergebnis wie unten gezeigt
So können wir gespeicherte Eigenschaften in Klassen, Strukturen, Aufzählungen basierend auf unseren Anforderungen in der Programmiersprache Swift definieren.
Gespeicherte Eigenschaften für konstante Strukturinstanzen
In Swift können wir eine Klasse oder Struktur mit gespeicherten Eigenschaften als Konstante definieren. Wenn wir eine konstante Eigenschaft mit einem Anfangswert definieren, dann ist es uns nicht möglich, diesen Wert zu ändern, denn sobald der Wert einer konstanten Variablen zugewiesen ist, sollte er in der gesamten Anwendung gleich bleiben.
Wenn wir versuchen, den Wert einer konstanten Eigenschaft während ihrer Initialisierung oder mit der Instanz einer Klasse zu ändern, wird der Compiler einen Fehler ausgeben.
Nachfolgend ein Beispiel für das Ändern eines konstanten Eigenschaftswertes nach der Initialisierung des Wertes während der Erstellung der Instanz einer Klasse.
struct UserDetails {
var firstName: String = „Rohini“
let lastName: String
}
var uinfo = UserDetails(firstName: „Suresh“, lastName: “ Dasari“)
uinfo.lastName = „Alavala“
print(„Name: \( uinfo.firstName) \(uinfo.lastName)“)
Wenn Sie das obige Beispiel beobachten, haben wir eine konstante Eigenschaft „lastName“ definiert und der Variablen bei der Erstellung der Klasseninstanz einen Wert zugewiesen. Danach versuchen wir wieder, den Wert der konstanten Variable zu ändern.
Wenn wir versuchen, das obige Beispiel in Swift Playground auszuführen, erhalten wir einen Fehler wie unten gezeigt
Fehler: kann der Eigenschaft nicht zugewiesen werden: ‚lastName‘ ist eine ‚let‘-Konstante
Wenn wir der konstanten Eigenschaft einen Wert zuweisen, der in der gesamten Anwendung gleich sein sollte, wird ein Fehler ausgelöst. Weitere Informationen zu Konstanten finden Sie in diesem Swift Constants.
Swift Lazy Stored Properties
In swift ist eine Lazy Stored Property eine Eigenschaft, deren Anfangswert erst bei der ersten Verwendung des Eigenschaftswertes geladen wird. In Swift können wir eine Lazy Stored Property definieren, indem wir das Schlüsselwort lazy vor der Deklaration verwenden.
In Swift sind Lazy Stored Properties nützlich, wenn der Anfangswert der Eigenschaft nicht geladen werden muss, bis er in der Anwendung verwendet wird. Angenommen, wir haben eine Eigenschaft und wir müssen einige komplexe Operationen durchführen, um den Wert zu laden oder zu initialisieren, aber es ist nur an bestimmten Stellen in diesem Fall erforderlich, wenn wir Lazy Stored Properties verwenden, werden diese Werte nicht geladen, bis wir es in unserem Code verwenden.
Nun werden wir sehen, wie lazy gespeicherte Eigenschaften in swift Anwendungen mit Beispielen zu verwenden.
Nachfolgend ist das Beispiel der Verwendung von lazy gespeicherten Eigenschaft in swift Programmiersprache.
class Student {
var name: String
lazy var studentInfo: String = {
return „Willkommen bei Tutlane, \(self.name)!“
}()
init(name: String) {
self.name = name
}
}
let stu = Student(name: „Suresh“)
print(stu.studentInfo)
Wenn Sie das obige Beispiel beobachten, haben wir eine träge gespeicherte Eigenschaft „studentInfo“ mit dem Schlüsselwort lazy definiert. Dieser Eigenschaftswert wird nicht geladen, bis die Druckanweisung die Eigenschaft von der Klasseninstanz „student“ aufruft.
Wenn wir das obige Programm in Swift Playground ausführen, erhalten wir ein Ergebnis wie unten gezeigt
Das ist, wie wir lazy gespeicherte Eigenschaften in einer swift Programmiersprache basierend auf unseren Anforderungen verwenden können.
Hier müssen wir uns daran erinnern, dass wir immer lazy gespeicherte Eigenschaften als Variable (var) deklarieren müssen, weil ihr Wert nicht abgerufen wird, bis die Instanzinitialisierung abgeschlossen ist, aber für konstante (let) Eigenschaften müssen einen Wert haben, bevor die Initialisierung abgeschlossen ist, das ist der Grund, warum wir immer lazy Eigenschaften als Variablen definieren müssen.
Swift Computed Properties
Im Gegensatz zu gespeicherten Eigenschaften werden berechnete Eigenschaften keinen Wert speichern, stattdessen werden berechnete Eigenschaften einen Getter und einen optionalen Setter bereitstellen, um andere Eigenschaftswerte indirekt abzurufen und zu setzen. Wir können berechnete Eigenschaften in Klassen, Strukturen und Aufzählungen definieren, die auf unseren Anforderungen basieren.
Nachfolgend ein Beispiel für die Definition von berechneten Eigenschaften mit Getter und Setter, um Werte in der Programmiersprache Swift zu setzen.
class Circle {
var radius : Double?
var cval : Double?
var Area: Double {
get {
return radius! * radius!
}
set (newArea){
cval = Double(newArea) * 3.14
}
}
}
let result = Circle()
result.Area = 20
print(result.cval)
Wenn Sie das obige Beispiel beobachten, setzen wir einen neuen Wert für die Eigenschaft „Area“ mithilfe von Getter- und Setter-Eigenschaften.
Wenn wir das obige Programm im Swift-Spielplatz ausführen, erhalten wir ein Ergebnis wie unten gezeigt
So können wir berechnete Eigenschaften in einer Swift-Programmiersprache verwenden, um Werte ohne Speicherung auf der Grundlage unserer Anforderungen zu verwenden.
Swift Read-Only Computed Properties
Eine berechnete Eigenschaft mit nur Getter, aber kein Setter ist als Read-Only Computed Properties bekannt. In Swift können wir auf schreibgeschützte berechnete Eigenschaften durch die Punkt (.)-Syntax zugreifen und sie geben immer einen Wert zurück.
Nachfolgend ein Beispiel für die Verwendung schreibgeschützter berechneter Eigenschaften in der Programmiersprache Swift.
class Multiplication {
var num1 : Int = 5
var num2 : Int = 5
var multiply: Int {
get {
return num1 * num2
}
}
}
let r = Multiplication()
print(r.multiply)
Im obigen Beispiel haben wir zwei Eigenschaften mit Standardwerten in der Klasse definiert und diese beiden Zahlen mit getter multipliziert. Danach haben wir eine Instanz für die Klasse und den Zugriff auf die Getter-Wert mit Punkt (.) syntax.
Wenn wir oben genannten Programm in swift Spielplatz erhalten wir das Ergebnis wie unten gezeigt
Dies ist, wie wir verwenden können read-only berechnete Eigenschaften, um die Werte mit Getter-Eigenschaft in swift Programmiersprache gesetzt.
Swift Property Observer
In Swift werden Property Observer verwendet, um die Änderungen des Eigenschaftswertes zu beobachten und darauf zu reagieren. Diese Property Observer werden jedes Mal aufgerufen, wenn sich der Eigenschaftswert ändert, auch wenn der neue Eigenschaftswert dem aktuellen Eigenschaftswert entspricht.
In swift können die Änderungen in den Eigenschaften durch die Verwendung der folgenden zwei Beobachter beobachtet werden.
- willSet – Dieser Beobachter wird aufgerufen, kurz bevor der Wert gespeichert wird.
- didSet – Dies ist ein Beobachter wird aufgerufen, nachdem der neue Wert gespeichert wird.
In swift können wir Eigenschaft Beobachter in allen gespeicherten Eigenschaften, außer faul gespeicherten Eigenschaften verwenden.
Nachfolgend ein Beispiel für die Verwendung von willSet- und didSet-Eigenschaften in einer Swift-Programmiersprache.
class Changes {
var num1: Int = 10 {
willSet(newvalue) {
print(„Wert von \(newvalue)“)
}
didSet {
if num1 > oldValue {
print(„Added \(num1 – oldValue)“)
}
}
}
}
let result = Changes()
result.num1 = 34
result.num1 = 987
Wenn Sie das obige Beispiel beobachten, haben wir willSet und didSet Beobachter verwendet und diese Eigenschaften werden immer dann aufgerufen, wenn der Wert der Eigenschaft geändert wird.
Wenn wir das obige Programm in Swift Playground ausführen, erhalten wir ein Ergebnis wie unten gezeigt
Wert von 34
Hinzufügen 24
Wert von 987
Hinzufügen 953
Swift Type Property
In swift, Instanzeigenschaften sind mit einer Instanz einer Klasse oder Struktur verbunden, die Typeigenschaften sind mit einem Typ selbst verbunden und gehören nicht zu einer Instanz des Typs.
In swift können wir eine Typ-Eigenschaft mit dem Schlüsselwort static und für berechnete Typ-Eigenschaften definieren und für Klassentypen müssen wir das Schlüsselwort class verwenden, aber es wird nicht erlauben, die Methoden oder Variablen der Oberklasse zu überschreiben.
Nachfolgend ein Beispiel für die Verwendung von Typeigenschaften in der Programmiersprache Swift.
struct typepro {
static let msg = „Welcome to Tutlane“
}
class Class1 {
func test() { print(typepro.msg) }
}
class Class2 {
func test() { print(typepro.msg) }
}
var ss = Class1()
ss.test()
Wenn Sie das obige Beispiel beobachten, haben wir eine Typeigenschaft mit dem statischen Schlüsselwort definiert und greifen auf Typeigenschaftswerte zu, indem wir den Namen referenzieren und die Punktsyntax verwenden, um auf den Wert zuzugreifen.
Wenn wir das obige Programm in der Programmiersprache Swift ausführen, erhalten wir ein Ergebnis wie unten gezeigt.
Swift Abfragen und Setzen von Typeigenschaften
In swift werden Typeigenschaften abgefragt und wir können dann den Wert mit Punkt (.) Syntax setzen, genau wie wenn wir eine Instanz erstellen und Eigenschaften Werte zuweisen. Allerdings werden die Typeigenschaften abgefragt und der Wert der Eigenschaften auf den Typ gesetzt, nicht auf eine Instanz dieses Typs.
Nachfolgend ein Beispiel für die Verwendung von Typeigenschaften in der Programmiersprache swift.
struct typerepo {
static var msg = „Welcome“
}
print(typerepo.msg)
typerepo.msg = „Welcome to Tutlane“
print(typerepo.msg)
Wenn Sie das obige Beispiel beobachten, haben wir eine Typeigenschaft erstellt und den Wert direkt durch die Verwendung einer Instanz dieses Typs gesetzt.