In swift worden eigenschappen gebruikt om attributen van een object te beschrijven en dat kunnen constanten of variabelen in klassen, structuren of opsommingen zijn.
In swift worden eigenschappen gebruikt om de waarden voor klassen, structuren of opsommingen op te slaan en eigenschappen hebben getter- en setter-methoden om de waarden van eigenschappen te wijzigen of in te stellen op basis van onze vereisten.
- Swift Definieer een eigenschap
- Swift Toewijzen en toegang krijgen tot eigenschappen
- Swift Stored Properties
- Opsgeslagen eigenschappen voor constante structuurinstanties
- Swift Lazy Stored Properties
- Swift Computed Properties
- Swift Read-Only Computed Properties
- Swift Property Observer
- Swift Type Property
- Swift Querying and Setting Type Properties
Swift Definieer een eigenschap
Hieronder volgt een eenvoudig voorbeeld van het creëren van een klasse met eigenschappen in een swift-programmeertaal.
klasse UserDetails {
var firstName: String = “”
var lastName: String = “”
}
Als u bovenstaand voorbeeld bekijkt, hebben we een klasse “UserDetails” gedefinieerd met twee eigenschappen (firstName, lastName).
Swift Toewijzen en toegang krijgen tot eigenschappen
Hieronder volgt een voorbeeld van declaratie en toewijzing van waarden aan de gedefinieerde eigenschappen in de klasse.
klasse UserDetails {
var firstName: String = “”
var lastName: String = “”
}
var uinfo = UserDetails()
uinfo.firstName = “Suresh”
uinfo.lastName = “Dasari”
print(“Naam: \uinfo.firstName) uinfo.lastName)”)
Als je bovenstaand voorbeeld bekijkt, hebben we twee eigenschappen “firstName”, “lastName” gedefinieerd en deze waarden zijn gekoppeld aan de klasse “UserDetails”. Daarna hebben we instantie voor die klasse en de toegang tot de eigenschappen in de klasse om waarden toe te wijzen op basis van onze requirements.
Wanneer we het bovenstaande programma in swift speeltuin krijgen we een resultaat zoals hieronder
Op dezelfde manier kunnen we definiëren en toegang eigenschappen in structuren en opsommingen op basis van onze eisen in swift programmeertaal.
We hebben een verschillend type eigenschappen beschikbaar in swift programmeertaal die zijn
- Stored Properties
- Computed Properties
Swift Stored Properties
In swift stored property is een constante of variabele en het wordt opgeslagen als een deel van een instantie van een bepaalde klasse of structuur. De opgeslagen eigenschap kan worden gebruikt om een variabele met var trefwoord en een constante met let trefwoord op te slaan.
We kunnen een standaardwaarden voor een opgeslagen eigenschap als onderdeel van zijn definitie en we kunnen de initiële waarden van een opgeslagen eigenschap tijdens zijn initialisatie wijzigen.
Nu zullen we zien hoe opgeslagen eigenschappen in klassen te definiëren en hoe initiële waarden van opgeslagen eigenschappen te wijzigen tijdens de initialisatie met voorbeeld.
Het volgende is het voorbeeld van het definiëren van opgeslagen eigenschappen als onderdeel van een klasse of structuur in een swift programmeertaal.
struct UserDetails {
var firstName: String = “Rohini”
let lastName: String
}
var uinfo = UserDetails(firstName: “Suresh”, lastName: ” Dasari”)
print(“Naam: \uinfo.firstName) uinfo.lastName)”)
Als je bovenstaand voorbeeld bekijkt, hebben we twee opgeslagen eigenschappen (firstName, lastName) gedefinieerd, een als variabele (var) en een andere als constante (let) met beginwaarden. Daarna hebben we instantie van structuur gemaakt en de initiële waarden gewijzigd tijdens de initialisatie.
Wanneer we het bovenstaande programma in swift playground uitvoeren, krijgen we een resultaat zoals hieronder
Dit is hoe we opgeslagen eigenschappen kunnen definiëren in klassen, structuren, enumeraties op basis van onze eisen in swift programmeertaal.
Opsgeslagen eigenschappen voor constante structuurinstanties
In swift kunnen we een klasse of structuur met opgeslagen eigenschappen definiëren als een constante. In het geval als we definiëren constante eigenschap met initiële waarde dan is het niet mogelijk voor ons om die waarde te wijzigen, omdat zodra de waarde die is toegewezen aan een constante variabele die hetzelfde moet zijn in de hele toepassing.
In het geval als we proberen om constante eigenschap waarde te wijzigen tijdens de initialisatie of met de instantie van een klasse, zal de compiler gooien een fout.
Het volgende is het voorbeeld van het wijzigen van constante opgeslagen eigenschap waarde na het initialiseren waarde tijdens de oprichting van instantie van class.
struct UserDetails {
var firstName: String = “Rohini”
let lastName: String
}
var uinfo = UserDetails(firstName: “Suresh”, lastName: ” Dasari”)
uinfo.lastName = “Alavala”
print(“Naam: \uinfo.firstName) uinfo.lastName)”)
Als je bovenstaand voorbeeld bekijkt, hebben we een constante eigenschap “lastName” gedefinieerd en de waarde aan de variabele toegewezen tijdens het creëren van een instantie van de klasse. Daarna proberen we de waarde van de constante variabele te wijzigen.
Wanneer we het bovenstaande voorbeeld in swift-speeltuin proberen uit te voeren, krijgen we een foutmelding zoals hieronder
Error: kan niet toewijzen aan eigenschap: ‘lastName’ is een ‘let’-constante
Als we eenmaal een waarde toewijzen aan de constante eigenschap, moet die in de hele toepassing hetzelfde zijn, anders wordt er een foutmelding weergegeven. Voor meer informatie over constanten, zie Swift Constants.
Swift Lazy Stored Properties
In swift is een lazy opgeslagen eigenschap een eigenschap waarvan de initiële waarde niet wordt geladen tot de eerste keer dat de eigenschap waarde wordt gebruikt. In swift, kunnen we een lazy opgeslagen eigenschap te definiëren door gebruik te maken lazy keyword vóór de verklaring.
In swift lazy opgeslagen eigenschappen zijn nuttig wanneer de initiële waarde van de eigenschap niet nodig om te laden tot het wordt gebruikt in de toepassing. Stel dat we een eigenschap en we moeten een aantal complexe operaties uit te voeren om te laden of initialiseren van de waarde, maar het is alleen nodig in specifieke plaatsen in dat geval als we lui opgeslagen eigenschappen die waarden te gebruiken zal niet worden geladen totdat we het gebruiken in onze code.
Nu zullen we zien hoe lazy opgeslagen eigenschappen te gebruiken in swift toepassingen met voorbeelden.
Het volgende is het voorbeeld van het gebruik van lazy opgeslagen eigenschap in swift programmeertaal.
class Student {
var naam: String
lazy var studentInfo: String = {
return “Welkom in Tutlane, jij(zelf.naam)!”
}()
init(naam: String) {
self.name = name
}
}
let stu = Student(name: “Suresh”)
print(stu.studentInfo)
Als u bovenstaand voorbeeld observeert, hebben we een luie opgeslagen eigenschap “studentInfo” gedefinieerd met behulp van lazy sleutelwoord. Deze eigenschap waarde zal niet geladen totdat de print verklaring oproep van de eigenschap van de student class instance.
Wanneer we draaien boven programma in swift speeltuin krijgen we een resultaat als hieronder
Dit is hoe we kunnen lui opgeslagen eigenschappen gebruiken in een swift programmeertaal op basis van onze eisen.
Hier moeten we niet vergeten dat altijd moeten we lui opgeslagen eigenschappen verklaren als een variabele (var), omdat de waarde niet opgehaald totdat instantie initialisatie voltooit, maar voor constante (let) eigenschappen moeten een waarde hebben voordat de initialisatie voltooit dat is de reden waarom altijd moeten we lui eigenschappen definiëren als variabelen.
Swift Computed Properties
In swift zullen computed properties, in tegenstelling tot stored properties, geen waarde opslaan in plaats daarvan zullen computed properties voorzien in een getter en een optionele setter om andere property-waarden indirect op te halen en in te stellen. We kunnen berekende eigenschappen definiëren in klassen, structuren en opsommingen op basis van onze vereisten.
Het volgende is het voorbeeld van het definiëren van berekende eigenschappen met behulp van getter en setter om waarden in te stellen in swift programmeertaal.
class Circle {
var radius : Double?
var cval : Double?
var Area: Dubbel {
get {
return radius! * straal!
}
set (newArea){
cval = Double(newArea) * 3.14
}
}
}
let result = Circle()
result.Area = 20
print(result.cval)
Als u bovenstaand voorbeeld bekijkt, stellen we een nieuwe waarde in voor de eigenschap “Area” met behulp van de eigenschappen getter en setter.
Wanneer we bovenstaand programma in swift playground uitvoeren, krijgen we een resultaat zoals hieronder
Dit is hoe we berekende eigenschappen in een swift programmeertaal kunnen gebruiken om waarden te gebruiken zonder op te slaan op basis van onze vereisten.
Swift Read-Only Computed Properties
Een berekende eigenschap met alleen getter maar geen setter staat bekend als een read-only berekende eigenschappen. In swift kunnen we read-only computed property benaderen via de punt (.) syntaxis en het geeft altijd een waarde terug.
Het volgende is het voorbeeld van het gebruik van read-only computed properties in een swift programmeertaal.
class Multiplication {
var num1 : Int = 5
var num2 : Int = 5
var multiply: Int {
get {
return num1 * num2
}
}
let r = Vermenigvuldiging()
print(r.vermenigvuldigen)
In bovenstaand voorbeeld hebben we twee eigenschappen met standaardwaarden in de klasse gedefinieerd en die twee getallen vermenigvuldigd met behulp van getter. Daarna hebben we een instantie voor de klasse en de toegang tot de getter waarde met behulp van punt (.) syntaxis.
Wanneer we bovenstaand programma in swift speeltuin krijgen we resultaat zoals hieronder getoond
Dit is hoe we kunnen gebruiken read-only berekende eigenschappen om de waarden met behulp van getter eigendom in swift programmeertaal in te stellen.
Swift Property Observer
In swift eigenschap observeerders worden gebruikt om te observeren en te reageren op de veranderingen in de waarde van de eigenschap en deze eigenschap observeerders zal elke keer bellen wanneer de waarde van de eigenschap verandert, zelfs als de nieuwe waarde van eigenschap hetzelfde als eigenschap huidige waarde.
In swift, kunnen de veranderingen in eigenschappen worden waargenomen door gebruik te maken van de volgende twee observers.
- willSet – Deze observer wordt aangeroepen vlak voordat de waarde wordt opgeslagen.
- didSet – Dit is een observer wordt aangeroepen nadat de nieuwe waarde is opgeslagen.
In swift, kunnen we eigenschap observers gebruiken in alle opgeslagen eigenschappen, behalve luie opgeslagen eigenschappen.
Hieronder volgt een voorbeeld van het gebruik van willSet en didSet eigenschappen in een swift programmeertaal.
klasse Veranderingen {
var num1: Int = 10 {
willSet(newvalue) {
print(“Waarde van num1(newvalue)”)
}
didSet {
if num1 > oldValue {
print(“Toegevoegd num1 – oldValue)”)
}
}
}
let result = Changes()
result.num1 = 34
result.num1 = 987
Als u bovenstaand voorbeeld bekijkt, hebben we willSet en didSet observers gebruikt en deze eigenschappen worden aangeroepen telkens wanneer de waarde van een eigenschap wordt gewijzigd.
Wanneer we het bovenstaande programma in de swift-speeltuin uitvoeren, krijgen we een resultaat zoals hieronder
Waarde van 34
Toegevoegde 24
Waarde van 987
Toegevoegde 953
Swift Type Property
In swift, instance eigenschappen worden geassocieerd met een instantie van klasse of structuur, het type eigenschappen worden geassocieerd met een type zelf, niet behoort tot een instantie van het type.
In swift kunnen we een type-eigenschap definiëren met het statische trefwoord en voor berekende type-eigenschappen en voor klassetypes moeten we het trefwoord class gebruiken, maar het staat niet toe om de methoden of variabelen van de superklasse te overschrijven.
Het volgende is het voorbeeld van het gebruik van type-eigenschappen in swift programmeertaal.
struct typepro {
static let msg = “Welcome to Tutlane”
}
class1 {
func test() {print(typepro.msg) }
}
class Class2 {
func test() {print(typepro.msg) }
}
var ss = Class1()
ss.test()
Als u bovenstaand voorbeeld bekijkt, hebben we een type-eigenschap gedefinieerd met het statische sleutelwoord en hebben we toegang tot de waarden van het type-eigenschap door te verwijzen naar de naam en de punt-syntaxis te gebruiken om toegang te krijgen tot de waarde.
Als we bovenstaand programma uitvoeren in de programmeertaal swift, krijgen we een resultaat zoals hieronder wordt getoond.
Swift Querying and Setting Type Properties
In swift worden type-eigenschappen opgevraagd en kunnen we vervolgens de waarde met punt (.) syntaxis instellen, net zoals wanneer we een instantie maken en waarden aan eigenschappen toekennen. De type-eigenschappen worden echter opgevraagd en de waarde wordt ingesteld op het type, niet op een instantie van dat type.
Het volgende is het voorbeeld van het gebruik van type-eigenschappen in de programmeertaal swift.
struct typerepo {
static var msg = “Welcome”
}
print(typerepo.msg)
typerepo.msg = “Welkom in Tutlane”
print(typerepo.msg)
Als je het bovenstaande voorbeeld bekijkt, hebben we type property gecreëerd en de waarde direct ingesteld door een instantie van dat type te gebruiken.