A swiftben a tulajdonságok egy objektum attribútumainak leírására szolgálnak, és ezek lehetnek konstansok vagy változók az osztályokban, struktúrákban vagy felsorolásokban.
A swiftben a tulajdonságok az osztályok, struktúrák vagy felsorolások értékeinek tárolására szolgálnak, és a tulajdonságok rendelkeznek getter és setter metódusokkal a tulajdonságértékek módosítására vagy beállítására a követelményeink alapján.
- Swift Define a Property
- Tulajdonságok gyors hozzárendelése és elérése
- Swift Stored Properties
- Stored Properties for Constant Structure Instances
- Swift Lazy Stored Properties
- Swift Computed Properties
- Swift Read-Only Computed Properties
- Swift Property Observer
- Swift Type Property
- Swift lekérdezés és a típus tulajdonságainak beállítása
Swift Define a Property
A következő egyszerű példa egy osztály létrehozására tulajdonságokkal a swift programozási nyelvben.
class UserDetails {
var firstName:
var lastName:
}
Ha megfigyeled a fenti példát, akkor definiáltunk egy “UserDetails” osztályt két tulajdonsággal (firstName, lastName).
Tulajdonságok gyors hozzárendelése és elérése
A következő példában az osztályban definiált tulajdonságokat deklaráljuk és értékeket rendelünk hozzájuk.
class UserDetails {
var firstName:
var lastName: String = “”
}
var uinfo = UserDetails()
uinfo.firstName = “Suresh”
uinfo.lastName = “Dasari”
print(“Name: \( uinfo.firstName) \(uinfo.lastName)”)
Ha megfigyeljük a fenti példát, akkor két tulajdonságot definiáltunk “firstName”, “lastName” és ezek az értékek a “UserDetails” osztályhoz tartoznak. Ezután létrehoztuk az osztály példányát, és hozzáférünk az osztályon belüli tulajdonságokhoz, hogy az igényeink alapján értékeket rendeljünk hozzá.
Ha a fenti programot futtatjuk a swift játszótéren, akkor az alábbiakban látható eredményt kapjuk
A swift programozási nyelvben ugyanígy definiálhatjuk és elérhetjük a struktúrák és felsorolások tulajdonságait a követelményeink alapján.
A swift programozási nyelvben különböző típusú tulajdonságok állnak rendelkezésünkre, ezek a következők
- Stored Properties
- Computed Properties
Swift Stored Properties
A swiftben a stored property egy konstans vagy változó, és egy adott osztály vagy struktúra példányának részeként tárolódik. A tárolt tulajdonság használható egy változó tárolására a var kulcsszóval és egy konstans tárolására a let kulcsszóval.
A tárolt tulajdonságoknak megadhatunk alapértelmezett értékeket a definíció részeként, és módosíthatjuk a tárolt tulajdonságok kezdeti értékeit az inicializálás során.
Most megnézzük, hogyan definiálhatunk tárolt tulajdonságokat osztályokban, és hogyan módosíthatjuk a tárolt tulajdonságok kezdeti értékeit az inicializálás során egy példával.
A következőkben egy swift programozási nyelvben a tárolt tulajdonságok osztály vagy struktúra részeként történő definiálására mutatunk példát.
struct UserDetails {
var firstName:
let lastName:
}
var uinfo = UserDetails(firstName: “Suresh”, lastName: ” Dasari”)
print(“Name: \( uinfo.firstName) \(uinfo.lastName)”)
Ha megfigyeled a fenti példát, akkor két tárolt tulajdonságot (firstName, lastName) definiáltunk, az egyiket változóként (var), a másikat konstansként (let) kezdeti értékekkel. Ezután létrehoztuk a struktúra példányát és módosítottuk a kezdeti értékeket az inicializálás során.
Ha a fenti programot futtatjuk a swift játszótéren, akkor az alábbiakban látható eredményt kapjuk
Így definiálhatunk tárolt tulajdonságokat osztályokban, struktúrákban, felsorolásokban az igényeink alapján a swift programozási nyelvben.
Stored Properties for Constant Structure Instances
A swiftben egy osztályt vagy struktúrát tárolt tulajdonságokkal konstansként definiálhatunk. Abban az esetben, ha konstans tulajdonságot definiálunk kezdeti értékkel, akkor nem tudjuk módosítani ezt az értéket, mert ha egyszer az értéket egy konstans változóhoz rendeljük, akkor annak az egész alkalmazásban azonosnak kell lennie.
Az esetben, ha megpróbáljuk módosítani a konstans tulajdonság értékét az inicializálás során vagy egy osztály példányával, a fordító hibát dob.
A következő példa a konstans tárolt tulajdonság értékének módosítására az érték inicializálása után az osztály példányának létrehozása során.
struct UserDetails {
var firstName: String = “Rohini”
let lastName:
}
var uinfo = UserDetails(firstName: “Suresh”, lastName: ” Dasari”)
uinfo.lastName = “Alavala”
print(“Name: \( uinfo.firstName) \(uinfo.lastName)”)
Ha megfigyeled a fenti példát, akkor definiáltunk egy konstans tulajdonságot “lastName” és értéket rendelünk a változóhoz az osztály példányának létrehozása során. Ezt követően ismét megpróbáljuk módosítani a konstans változó értékét.
Ha megpróbáljuk a fenti példát futtatni a swift playgroundban, akkor az alábbi hibaüzenetet kapjuk
Error: cannot assign to property: ‘lastName’ is a ‘let’ constant
Mihelyt értéket rendelünk a konstans tulajdonsághoz, annak az egész alkalmazásban azonosnak kell lennie, különben hibát fog dobni. A konstansokkal kapcsolatos további információkért nézd meg ezt a Swift Constants.
Swift Lazy Stored Properties
A swiftben a lazy stored property olyan tulajdonság, amelynek kezdeti értéke csak a tulajdonság értékének első használatakor töltődik be. A swiftben a lusta tárolt tulajdonságot a deklaráció előtt a lazy kulcsszó használatával definiálhatjuk.
A swiftben a lusta tárolt tulajdonságok akkor hasznosak, ha a tulajdonság kezdeti értékét nem kell betölteni, amíg az alkalmazásban nem használjuk. Tegyük fel, hogy van egy tulajdonságunk, és szükségünk van néhány összetett műveletre az érték betöltéséhez vagy inicializálásához, de csak bizonyos helyeken szükséges, ebben az esetben, ha lusta tárolt tulajdonságokat használunk, ezek az értékek nem töltődnek be, amíg nem használjuk a kódunkban.
Most megnézzük, hogyan használjuk a lusta tárolt tulajdonságokat a swift alkalmazásokban példákkal.
A következő a példa a lusta tárolt tulajdonságok használatára a swift programozási nyelvben.
class Student {
var name: String
lazy var studentInfo: String = {
return “Welcome to Tutlane, \(self.name)!”
}()
init(name: String) {
self.name = name
}
}
let stu = Student(name: “Suresh”)
print(stu.studentInfo)
Ha megfigyeled a fenti példát, akkor a lazy kulcsszóval definiáltunk egy lusta tárolt “studentInfo” tulajdonságot. Ez a tulajdonság értéke nem töltődik be, amíg a print utasítás meg nem hívja a tulajdonságot a student osztálypéldányból.
Ha a fenti programot lefuttatjuk a swift játszótéren, akkor az alábbiakban látható eredményt kapjuk
Így használhatjuk a lusta tárolt tulajdonságokat a swift programozási nyelvben az igényeink alapján.
Itt kell megjegyeznünk, hogy mindig változónak (var) kell deklarálnunk a lusta tárolt tulajdonságokat, mert az értékét nem kapjuk meg, amíg a példány inicializálása be nem fejeződik, de a konstans (let) tulajdonságoknak értéket kell kapniuk az inicializálás befejezése előtt, ezért mindig változóként kell definiálnunk a lusta tulajdonságokat.
Swift Computed Properties
A swiftben a tárolt tulajdonságokkal ellentétben a computed properties nem tárol értéket, hanem a computed properties egy gettert és egy opcionális settert biztosít más tulajdonságértékek közvetett lekéréséhez és beállításához. Számított tulajdonságokat osztályokban, struktúrákban és felsorolásokban definiálhatunk igényeink alapján.
A következő példában a swift programozási nyelvben számolt tulajdonságokat definiálhatunk a getter és setter segítségével az értékek beállításához.
class Circle {
var radius : Double?
var cval : Double?
var Area: Double {
get {
return radius! * sugár!
}
set (newArea){
cval = Double(newArea) * 3.14
}
}
}
}
let result = Circle()
result.Area = 20
print(result.cval)
Ha megfigyeljük a fenti példát, akkor a “Area” tulajdonság új értékét állítjuk be a getter és setter tulajdonságok segítségével.
Ha a fenti programot futtatjuk a swift játszótéren, akkor az alábbiakban látható eredményt kapjuk
Így használhatjuk a swift programozási nyelvben a számított tulajdonságokat, hogy tárolás nélküli értékeket használjunk igényeink alapján.
Swift Read-Only Computed Properties
A csak getterrel, de setter nélkül rendelkező számított tulajdonságot read-only computed propertiesnek nevezzük. A swiftben pont (.) szintaxissal érhetjük el a csak olvashatóan kiszámított tulajdonságot, és mindig visszaad egy értéket.
A következőkben egy példa a csak olvashatóan kiszámított tulajdonságok használatára a swift programozási nyelvben.
class Multiplication {
var num1 : Int = 5
var num2 : Int = 5
var multiply: Int {
get {
return num1 * num2
}
}
}
let r = Multiplication()
print(r.multiply)
A fenti példában két tulajdonságot definiáltunk alapértelmezett értékekkel az osztályban és a két számot szorozzuk meg a getter segítségével. Ezután létrehoztunk egy példányt az osztályhoz, és a getter értékét pont (.) szintaxissal érjük el.
Amikor a fenti programot futtatjuk a swift játszótéren, az alábbiakban látható eredményt kapjuk
Így használhatjuk a csak olvasható kiszámított tulajdonságokat az értékek beállításához a getter tulajdonság használatával a swift programozási nyelvben.
Swift Property Observer
A swiftben a tulajdonságmegfigyelőket arra használják, hogy megfigyeljék és reagáljanak a tulajdonságérték változásaira, és ezek a tulajdonságmegfigyelők minden alkalommal meghívják, amikor a tulajdonság értéke megváltozik, még akkor is, ha a tulajdonság új értéke megegyezik a tulajdonság aktuális értékével.
A swiftben a tulajdonságok változásait a következő két megfigyelővel lehet megfigyelni.
- willSet – Ezt a megfigyelőt közvetlenül az érték tárolása előtt hívja meg.
- didSet – Ezt a megfigyelőt az új érték tárolása után hívja meg.
A swiftben bármilyen tárolt tulajdonságban használhatunk tulajdonságmegfigyelőt, kivéve a lusta tárolt tulajdonságokat.
A következőkben a willSet és didSet tulajdonságok swift programozási nyelven történő használatára mutatunk példát.
class Changes {
var num1:
willSet(newvalue) {
print(“A \(newvalue) értéke”)
}
didSet {
if num1 > oldValue {
print(“Added \(num1 – oldValue)”)
}
}
}
}
let result = Changes()
result.num1 = 34
result.num1 = 987
Ha megfigyeljük a fenti példát, akkor willSet és didSet megfigyelőket használtunk, és ezeket a tulajdonságokat hívjuk meg, amikor a tulajdonság értéke megváltozik.
Ha a fenti programot futtatjuk a swift játszótéren, akkor az alábbiakban látható eredményt kapjuk
Value of 34
Added 24
Value of 987
Added 953
Swift Type Property
In swift, példánytulajdonságok egy osztály vagy struktúra példányához kapcsolódnak, a típustulajdonságok magához a típushoz kapcsolódnak, nem tartoznak a típus bármely példányához.
A swiftben static kulcsszóval definiálhatunk típustulajdonságot és a számított típustulajdonságokhoz, az osztálytípusokhoz pedig a class kulcsszót kell használnunk, de ez nem teszi lehetővé a szuperosztály metódusainak vagy változóinak felülírását.
A következő a példa a típustulajdonság használatára a swift programozási nyelvben.
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()
Ha megfigyeljük a fenti példát, akkor static kulcsszóval definiáltunk egy típustulajdonságot, és a típustulajdonság értékeit a névre való hivatkozással és a pont szintaxis használatával érjük el az értéket.
Ha a fenti programot swift programozási nyelven futtatjuk, akkor az alábbiakban látható eredményt kapjuk.
Swift lekérdezés és a típus tulajdonságainak beállítása
A swiftben a típus tulajdonságait lekérdezzük, majd pont (.) szintaxissal beállíthatjuk az értéket, ugyanúgy, mint amikor létrehozunk egy példányt és értékeket rendelünk a tulajdonságokhoz. Azonban a típustulajdonságok lekérdezése és a tulajdonságok értékének beállítása a típuson történik, nem pedig a típus egy példányán.
A következő a példa a típustulajdonságok használatára a swift programozási nyelvben.
struct typerepo {
static var msg = “Welcome”
}
print(typerepo.msg)
typerepo.msg = “Welcome to Tutlane”
print(typerepo.msg)
Ha megfigyeljük a fenti példát, létrehoztuk a típus tulajdonságot és az értéket közvetlenül a típus egy példányának használatával állítjuk be.