I Swift används egenskaper för att beskriva attribut för ett objekt och dessa kan vara konstanter eller variabler i klasser, strukturer eller uppräkningar.
I swift används egenskaper för att lagra värden för klasser, strukturer eller uppräkningar och egenskaper har getter- och settermetoder för att ändra eller ställa in egenskapsvärden baserat på våra krav.
- Swift definierar en egenskap
- Swift Assign and Access Properties
- Swift Stored Properties
- Lagrade egenskaper för konstanta strukturinstanser
- Swift Lazy Stored Properties
- Swift Computed Properties
- Swift Read-Only Computed Properties
- Swift Property Observer
- Swift Type Property
- Swift söker och ställer in typegenskaper
Swift definierar en egenskap
Följande är det enkla exemplet på att skapa en klass med egenskaper i ett programmeringsspråk swift.
class UserDetails {
var firstName: String = ””
var lastName:
var lastName:
var lastName: String = ””
}
Om du ser ovanstående exempel har vi definierat en klass ”UserDetails” med två egenskaper (firstName, lastName).
Swift Assign and Access Properties
Nedan följer ett exempel på hur man deklarerar och tilldelar värden till de definierade egenskaperna i klassen.
class UserDetails {
var firstName: String = ””
var lastName: String = ””
}
var uinfo = UserDetails()
uinfo.firstName = ”Suresh”
uinfo.lastName = ”Dasari”
print(”Name: \( uinfo.firstName) \(uinfo.lastName)”)
Om du observerar exemplet ovan har vi definierat två egenskaper ”firstName”, ”lastName” och dessa värden är associerade med klassen ”UserDetails”. Efter det skapade vi en instans för den klassen och får tillgång till egenskaperna i klassen för att tilldela värden baserat på våra krav.
När vi kör ovanstående program i Swift Playground får vi ett resultat som visas nedan
På samma sätt kan vi definiera och få tillgång till egenskaper i strukturer och uppräkningar baserat på våra krav i programmeringsspråket Swift.
Vi har olika typer av egenskaper tillgängliga i programmeringsspråket swift som är
- Stored Properties
- Computed Properties
Swift Stored Properties
I swift är lagrad egenskap en konstant eller variabel och den lagras som en del av en instans av en viss klass eller struktur. Den lagrade egenskapen kan användas för att lagra en variabel med nyckelordet var och en konstant med nyckelordet let.
Vi kan tillhandahålla standardvärden för en lagrad egenskap som en del av dess definition och vi kan ändra de initiala värdena för en lagrad egenskap under dess initialisering.
Nu ska vi se hur man definierar lagrade egenskaper i klasser och hur man ändrar initiala värden för lagrade egenskaper under dess initialisering med exempel.
Nedan följer ett exempel på hur man definierar lagrade egenskaper som en del av en klass eller struktur i programmeringsspråket Swift.
struct UserDetails {
var firstName: String = ”Rohini”
let lastName: String
}
var uinfo = UserDetails(firstName: ”Suresh”, lastName: ” Dasari”)
print(”Namn:
Om du observerar ovanstående exempel har vi definierat två lagrade egenskaper (firstName, lastName), en som en variabel (var) och en annan som konstant (let) med initiala värden. Därefter skapade vi en instans av strukturen och modifierade de initiala värdena under dess initialisering.
När vi kör ovanstående program i Swift Playground får vi ett resultat som visas nedan
Detta är hur vi kan definiera lagrade egenskaper i klasser, strukturer, uppräkningar baserat på våra krav i programmeringsspråket Swift.
Lagrade egenskaper för konstanta strukturinstanser
I Swift kan vi definiera en klass eller struktur med lagrade egenskaper som en konstant. I fallet om vi definierar konstant egenskap med initialt värde så är det inte möjligt för oss att ändra det värdet eftersom när värdet tilldelas en konstant variabel som ska vara densamma i hela applikationen.
Om vi försöker ändra värdet av en konstant egenskap under dess initialisering eller med instansen av en klass, kommer kompilatorn att kasta ett fel.
Följande är exemplet på att ändra värdet av en konstant lagrad egenskap efter att ha initialiserat värdet under skapandet av en instans av klassen.
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)”)
Om du observerar exemplet ovan har vi definierat en konstant egenskap ”lastName” och tilldelat ett värde till variabeln under skapandet av en klassinstans. Efter det försöker vi återigen ändra värdet på den konstanta variabeln.
När vi försöker köra ovanstående exempel i Swift Playground får vi ett fel som visas nedan
Fel: kan inte tilldela egenskapen: ”lastName” är en ”låt”-konstant
När vi tilldelar ett värde till den konstanta egenskapen ska det vara detsamma i hela applikationen annars kommer det att kasta ett fel. Mer information om konstanter finns här: Swift Constants.
Swift Lazy Stored Properties
I swift lazy stored property är en egenskap vars initiala värde inte laddas förrän första gången egenskapsvärdet används. I swift kan vi definiera en lazy stored property genom att använda nyckelordet lazy före deklarationen.
In swift lazy stored properties är användbara när det initiala värdet av egenskapen inte behöver laddas förrän den används i programmet. Antag att vi har en egenskap och vi behöver utföra några komplexa operationer för att ladda eller initialisera värdet men det krävs bara på specifika platser i det fallet om vi använder lata lagrade egenskaper kommer dessa värden inte att laddas tills vi använder dem i vår kod.
Nu ska vi se hur man använder lata lagrade egenskaper i swift-applikationer med exempel.
Följande är exemplet på hur man använder lata lagrade egenskaper i programmeringsspråket swift.
class Student {
var name: String
lazy var studentInfo: String = {
return ”Välkommen till Tutlane, \(self.name)!”
}()
init(name: String) {
self.name = name
}
}
let stu = Student(name: ”Suresh”)
print(stu.studentInfo)
Om du observerar exemplet ovan har vi definierat en lat lagrad egenskap ”studentInfo” med hjälp av nyckelordet lazy. Detta egenskapsvärde kommer inte att laddas förrän print-anvisningen kallar egenskapen från studentklassens instans.
När vi kör ovanstående program i Swift Playground kommer vi att få ett resultat som visas nedan
Detta är hur vi kan använda lata lagrade egenskaper i ett swift programmeringsspråk baserat på våra krav.
Här måste vi komma ihåg att vi alltid måste deklarera lata lagrade egenskaper som en variabel (var) eftersom dess värde inte hämtas förrän initialiseringen av instansen är klar, men för konstanta (let) egenskaper måste ha ett värde innan initialiseringen är klar det är anledningen till att vi alltid måste definiera lata egenskaper som variabler.
Swift Computed Properties
I swift till skillnad från lagrade egenskaper kommer computed properties inte att lagra ett värde istället kommer computed properties att tillhandahålla en getter och en valfri setter för att hämta och ställa in andra egenskapsvärden indirekt. Vi kan definiera beräknade egenskaper i klasser, strukturer och uppräkningar baserat på våra krav.
Nedan följer ett exempel på hur man definierar beräknade egenskaper med hjälp av getter och setter för att ställa in värden i programmeringsspråket Swift.
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)
Om du observerar ovanstående exempel ställer vi in ett nytt värde för egenskapen ”Area” med hjälp av getter- och setter-egenskaper.
När vi kör ovanstående program i swift playground får vi ett resultat som visas nedan
Det här är hur vi kan använda beräknade egenskaper i ett swift-programmeringsspråk för att använda värden utan att lagra baserat på våra krav.
Swift Read-Only Computed Properties
En beräknad egenskap som bara har en getter men ingen setter är känd som en read-only computed properties. I Swift kan vi få tillgång till read-only computed properties genom punkt (.) syntaxen och den returnerar alltid ett värde.
Nedan följer ett exempel på användning av read-only computed properties i programmeringsspråket Swift.
class Multiplication {
var num1 : Int = 5
var num2 : Int = 5
var multiply: Int {
get {
return num1 * num2
}
}
}
let r = Multiplikation()
print(r.multiply)
I exemplet ovan har vi definierat två egenskaper med standardvärden i klassen och multiplicerat dessa två tal med getter. Efter det skapade vi en instans för klassen och får tillgång till gettervärdet med hjälp av punkt (.) syntax.
När vi kör ovanstående program i swift playround får vi ett resultat som visas nedan
Detta är hur vi kan använda skrivskyddade beräknade egenskaper för att ställa in värdena med hjälp av getteregenskaper i programmeringsspråket swift.
Swift Property Observer
I swift används egenskapsobservatörer för att observera och reagera på förändringar i egenskapsvärdet och dessa egenskapsobservatörer anropar varje gång när egenskapsvärdet förändras, även om det nya värdet på egenskapen är detsamma som egenskapens nuvarande värde.
I swift kan ändringarna i egenskaper observeras med hjälp av följande två observatörer.
- willSet – Denna observatör anropas precis innan värdet lagras.
- didSet – Detta är en observatör som anropas efter det att det nya värdet har lagrats.
I swift kan vi använda egendomsobservatörer i alla lagrade egenskaper, utom i lazy lagrade egenskaper.
Följande är exemplet på användning av willSet och didSet egenskaper i ett swift programmeringsspråk.
class Changes {
var num1: Int = 10 {
willSet(newvalue) {
print(”Värdet av \(newvalue)”)
}
didSet {
if num1 > oldValue {
print(”Lagt till \(num1 -) oldValue)”)
}
}
}
}
let result = Changes()
result.num1 = 34
result.num1 = 987
Om du observerar exemplet ovan har vi använt observatörerna willSet och didSet och dessa egenskaper anropas när värdet på egenskapen ändras.
När vi kör ovanstående program i swift playgroup får vi ett resultat som visas nedan
Värde av 34
Adderat 24
Värde av 987
Adderat 953
Swift Type Property
In swift, instansegenskaper är associerade med en instans av en klass eller struktur, typegenskaperna är associerade med själva typen och tillhör inte någon instans av typen.
I swift kan vi definiera en typegenskap med statiska nyckelord och för beräknade typegenskaper och för klasstyper måste vi använda nyckelordet class men det tillåter inte att åsidosätta överklassens metoder eller variabler.
Nedan följer ett exempel på hur man använder typegenskaper i programmeringsspråket 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()
Om du observerar ovanstående exempel har vi definierat en typegenskap med nyckelordet static och får tillgång till typegenskapens värden genom att hänvisa till namnet och använda punktsyntaxen för att få tillgång till värdet.
När vi kör ovanstående program i programmeringsspråket swift får vi ett resultat som visas nedan.
Swift söker och ställer in typegenskaper
I swift söks typegenskaper och vi kan sedan ställa in värdet med punkt (.) syntaxen precis som när vi skapar en instans och tilldelar värden till egenskaper. Typegenskaperna frågas dock ut och ställer in egenskapsvärdet på typen, inte på en instans av den typen.
Nedan följer ett exempel på hur man använder typegenskaper i programmeringsspråket swift.
struct typerepo {
static var msg = ”Welcome”
}
print(typerepo.msg)
typerepo.msg = ”Welcome to Tutlane”
print(typerepo.msg)
Om du observerar exemplet ovan har vi skapat en typegenskap och fastställt värdet direkt genom att använda en instans av den typen.