În swift, proprietățile sunt utilizate pentru a descrie atributele unui obiect și acestea pot fi constante sau variabile în clase, structuri sau enumerări.
În swift, proprietățile sunt utilizate pentru a stoca valorile pentru clase, structuri sau enumerări, iar proprietățile au metode getter și setter pentru a modifica sau seta valorile proprietăților în funcție de cerințele noastre.
- Swift Define a Property
- Swift Assign and Access Properties
- Proprietăți stocate în swift
- Proprietăți stocate pentru instanțe de structuri constante
- Swift Lazy Stored Properties
- Proprietăți calculate în swift
- Proprietăți calculate cu citire exclusivă în swift
- Swift Property Observer
- Proprietate de tip swift
- Swift Interogarea și setarea proprietăților de tip
Swift Define a Property
În continuare este prezentat un exemplu simplu de creare a unei clase cu proprietăți într-un limbaj de programare swift.
class UserDetails {
var firstName: String = „”
var lastName: String = „”
}
Dacă observați exemplul de mai sus, am definit o clasă „UserDetails” cu două proprietăți (firstName, lastName).
Swift Assign and Access Properties
În cele ce urmează este un exemplu de declarare și atribuire a valorilor proprietăților definite în clasă.
clasa UserDetails {
var firstName: String = „”
var lastName: String = „”
}
var uinfo = UserDetails()
uinfo.firstName = „Suresh”
uinfo.lastName = „Dasari”
print(„Name: \( uinfo.firstName) \(uinfo.lastName)”)
Dacă observați exemplul de mai sus, am definit două proprietăți „firstName”, „lastName”, iar aceste valori sunt asociate cu clasa „UserDetails”. După aceea am creat o instanță pentru această clasă și am accesat proprietățile din cadrul clasei pentru a atribui valori în funcție de cerințele noastre.
Când executăm programul de mai sus în swift playground vom obține un rezultat ca cel arătat mai jos
În același mod putem defini și accesa proprietăți în structuri și enumerări pe baza cerințelor noastre în limbajul de programare swift.
Avem un tip diferit de proprietăți disponibile în limbajul de programare swift, acestea sunt
- Proprietăți stocate
- Proprietăți calculate
Proprietăți stocate în swift
În swift, o proprietate stocată este o constantă sau o variabilă și este stocată ca parte a unei instanțe a unei anumite clase sau structuri. Proprietatea stocată poate fi utilizată pentru a stoca o variabilă cu ajutorul cuvântului cheie var și o constantă cu ajutorul cuvântului cheie let.
Puteți furniza valori implicite pentru o proprietate stocată ca parte a definiției sale și puteți modifica valorile inițiale ale unei proprietăți stocate în timpul inițializării acesteia.
Acum vom vedea cum să definim proprietățile stocate în clase și cum să modificăm valorile inițiale ale proprietăților stocate în timpul inițializării acestora cu ajutorul unui exemplu.
Urmează un exemplu de definire a proprietăților stocate ca parte a unei clase sau structuri într-un limbaj de programare swift.
struct UserDetails {
var firstName: String = „Rohini”
let lastName: String
}
var uinfo = UserDetails(firstName: „Suresh”, lastName: ” Dasari”)
print(„Name: \( uinfo.firstName) \(uinfo.lastName)”)
Dacă observați exemplul de mai sus, am definit două proprietăți stocate (firstName, lastName), una ca o variabilă (var) și alta ca o constantă (let) cu valori inițiale. După aceea am creat o instanță a structurii și am modificat valorile inițiale în timpul inițializării acesteia.
Când vom rula programul de mai sus în swift playground vom obține un rezultat ca cel arătat mai jos
Acesta este modul în care putem defini proprietăți stocate în clase, structuri, enumerări în funcție de cerințele noastre în limbajul de programare swift.
Proprietăți stocate pentru instanțe de structuri constante
În swift, putem defini o clasă sau o structură cu proprietăți stocate ca o constantă. În cazul în care definim o proprietate constantă cu o valoare inițială, atunci nu ne este posibil să modificăm acea valoare, deoarece odată ce valoarea atribuită unei variabile constante ar trebui să fie aceeași în întreaga aplicație.
În cazul în care încercăm să modificăm valoarea unei proprietăți constante în timpul inițializării acesteia sau cu instanța unei clase, compilatorul va arunca o eroare.
Urmează un exemplu de modificare a valorii unei proprietăți constante stocate după inițializarea valorii în timpul creării instanței clasei.
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)”)
Dacă observați exemplul de mai sus, am definit o proprietate constantă „lastName” și am atribuit o valoare variabilei în timpul creării instanței clasei. După aceea, încercăm din nou să modificăm valoarea variabilei constante.
Când încercăm să rulăm exemplul de mai sus în swift playground, vom primi o eroare, așa cum se arată mai jos
Error: cannot assign to property: ‘lastName’ is a ‘let’ constant
După ce atribuim o valoare proprietății constante, aceasta trebuie să fie aceeași în întreaga aplicație, altfel se va afișa o eroare. Pentru mai multe informații despre constante, consultați acest Swift Constants.
Swift Lazy Stored Properties
În swift lazy stored property este o proprietate a cărei valoare inițială nu este încărcată până la prima utilizare a valorii proprietății. În swift, putem defini o proprietate lazy stored folosind cuvântul cheie lazy înainte de declarația sa.
În swift proprietățile lazy stored sunt utile atunci când valoarea inițială a proprietății nu trebuie să se încarce până când aceasta este utilizată în aplicație. Să presupunem că avem o proprietate și trebuie să efectuăm unele operații complexe pentru a încărca sau a inițializa valoarea, dar aceasta este necesară numai în anumite locuri, în acest caz, dacă folosim proprietăți stocate leneșe, aceste valori nu vor fi încărcate până când nu le vom utiliza în codul nostru.
Acum vom vedea cum să folosim proprietățile stocate leneșe în aplicațiile swift cu exemple.
Urmează un exemplu de utilizare a proprietăților stocate leneșe în limbajul de programare swift.
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)
Dacă observați exemplul de mai sus, am definit o proprietate stocată leneșă „studentInfo” folosind cuvântul cheie lazy. Valoarea acestei proprietăți nu se va încărca până când instrucțiunea print nu va apela proprietatea din instanța clasei student.
Când rulăm programul de mai sus în swift playground vom obține un rezultat ca cel arătat mai jos
Acesta este modul în care putem utiliza proprietățile stocate leneșe într-un limbaj de programare swift pe baza cerințelor noastre.
Aici trebuie să ne amintim că întotdeauna trebuie să declarăm proprietățile stocate leneșe ca o variabilă (var), deoarece valoarea sa nu este recuperată până când se finalizează inițializarea instanței, dar pentru proprietățile constante (let) proprietățile trebuie să aibă o valoare înainte de finalizarea inițializării, acesta este motivul pentru care întotdeauna trebuie să definim proprietățile leneșe ca variabile.
Proprietăți calculate în swift
În swift, spre deosebire de proprietățile stocate, proprietățile calculate nu vor stoca o valoare, în schimb proprietățile calculate vor furniza un getter și un setter opțional pentru a prelua și seta indirect valorile altor proprietăți. Putem defini proprietăți calculate în clase, structuri și enumerații în funcție de cerințele noastre.
În continuare este prezentat un exemplu de definire a proprietăților calculate folosind getter și setter pentru a seta valori în limbajul de programare 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)
Dacă observați exemplul de mai sus, stabilim o nouă valoare pentru proprietatea „Area” utilizând proprietățile getter și setter.
Când executăm programul de mai sus în swift playground vom obține un rezultat așa cum se arată mai jos
Acesta este modul în care putem utiliza proprietăți calculate într-un limbaj de programare swift pentru a utiliza valori fără a le stoca în funcție de cerințele noastre.
Proprietăți calculate cu citire exclusivă în swift
O proprietate calculată care are doar getter, dar nu și setter, este cunoscută sub numele de proprietate calculată cu citire exclusivă. În swift putem accesa o proprietate calculată numai pentru citire prin intermediul sintaxei punct (.) și aceasta returnează întotdeauna o valoare.
În cele ce urmează este un exemplu de utilizare a proprietăților calculate numai pentru citire într-un limbaj de programare swift.
class Multiplication {
var num1 : Int = 5
var num2 : Int = 5
var multiply: Int {
get {
return num1 * num2
}
}
}
let r = Multiplication()
print(r.multiply)
În exemplul de mai sus am definit două proprietăți cu valori implicite în clasă și am înmulțit aceste două numere folosind getterul. După aceea, am creat o instanță pentru clasă și am accesat valoarea getter folosind sintaxa punct (.).
Când rulăm programul de mai sus pe terenul de joacă swift, vom obține un rezultat așa cum se arată mai jos
Acesta este modul în care putem folosi proprietățile calculate numai pentru citire pentru a seta valorile folosind proprietatea getter în limbajul de programare swift.
Swift Property Observer
În swift, observatorii de proprietăți sunt utilizați pentru a observa și a răspunde la modificările valorii proprietăților, iar acești observatori de proprietăți vor apela de fiecare dată când se modifică valoarea proprietății, chiar dacă noua valoare a proprietății este aceeași cu valoarea curentă a proprietății.
În swift, modificările proprietăților pot fi observate prin utilizarea următorilor doi observatori.
- willSet – Acest observator este apelat chiar înainte ca valoarea să fie stocată.
- didSet – Acesta este un observator care este apelat după ce noua valoare este stocată.
În swift, putem utiliza observatori de proprietate în orice proprietate stocată, cu excepția proprietăților stocate leneșe.
În continuare este prezentat exemplul de utilizare a proprietăților willSet și didSet într-un limbaj de programare swift.
clasa Changes {
var num1: Int = 10 {
willSet(newvalue) {
print(„Valoarea lui \(newvalue)”)
}
didSet {
if num1 > oldValue {
print(„S-a adăugat \(num1 – oldValue)”)
}
}
}
}
let result = Changes()
result.num1 = 34
result.num1 = 987
Dacă observați exemplul de mai sus, am folosit observatorii willSet și didSet, iar aceste proprietăți sunt apelate ori de câte ori se modifică valoarea unei proprietăți.
Când executăm programul de mai sus în swift playground vom obține un rezultat ca cel arătat mai jos
Valoare de 34
Adaugat 24
Valoare de 987
Adaugat 953
Proprietate de tip swift
În swift, proprietățile de instanță sunt asociate cu o instanță de clasă sau structură, proprietățile de tip sunt asociate cu un tip în sine, care nu aparține niciunei instanțe a tipului.
În swift, putem defini o proprietate de tip cu ajutorul cuvântului cheie static și pentru proprietățile de tip calculate, iar pentru tipurile de clasă trebuie să folosim cuvântul cheie class, dar acesta nu va permite suprascrierea metodelor sau variabilelor din superclasă.
Urmează un exemplu de utilizare a proprietăților de tip în limbajul de programare 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()
Dacă observați exemplul de mai sus, am definit o proprietate de tip cu cuvântul cheie static și am accesat valorile proprietăților de tip făcând referire la nume și folosind sintaxa punct pentru a accesa valoarea.
Când executăm programul de mai sus în limbajul de programare swift, vom obține un rezultat ca cel prezentat mai jos.
Swift Interogarea și setarea proprietăților de tip
În swift, proprietățile de tip sunt interogate și apoi putem seta valoarea cu sintaxa punct (.) la fel ca atunci când creăm o instanță și atribuim valori proprietăților. Cu toate acestea, proprietățile de tip sunt interogate și setează valoarea proprietăților asupra tipului, nu asupra unei instanțe a acelui tip.
Urmează un exemplu de utilizare a proprietăților de tip în limbajul de programare swift.
struct typerepo {
static var msg = „Welcome”
}
print(typerepo.msg)
typerepo.msg = „Welcome to Tutlane”
print(typerepo.msg)
Dacă observați exemplul de mai sus, am creat o proprietate de tip și am setat valoarea direct prin utilizarea unei instanțe a acelui tip.