In swift, le proprietà sono usate per descrivere gli attributi di un oggetto e queste possono essere costanti o variabili in classi, strutture o enumerazioni.
In swift le proprietà sono usate per memorizzare i valori per classi, strutture o enumerazioni e le proprietà hanno metodi getter e setter per modificare o impostare i valori delle proprietà in base alle nostre esigenze.
- Swift definisce una proprietà
- Assegnazione rapida e accesso alle proprietà
- Proprietà memorizzate swift
- Proprietà memorizzate per istanze di strutture costanti
- Swift Lazy Stored Properties
- Proprietà computerizzate swift
- Swift Read-Only Computed Properties
- Swift Property Observer
- Swift Proprietà di tipo
- Swift interroga e imposta le proprietà del tipo
Swift definisce una proprietà
Di seguito il semplice esempio di creazione di una classe con proprietà in un linguaggio di programmazione swift.
classe UserDetails {
var firstName: String = “”
var lastName: String = “”
}
Se osservate l’esempio precedente abbiamo definito una classe “UserDetails” con due proprietà (firstName, lastName).
Assegnazione rapida e accesso alle proprietà
Di seguito è riportato l’esempio di dichiarazione e assegnazione di valori alle proprietà definite nella classe.
classe UserDetails {
var firstName: String = “”
var lastName: String = “”
}
var uinfo = UserDetails()
uinfo.firstName = “Suresh”
uinfo.lastName = “Dasari”
print(“Name: \( uinfo.firstName) \(uinfo.lastName)”)
Se osservate l’esempio precedente abbiamo definito due proprietà “firstName”, “lastName” e questi valori sono associati alla classe “UserDetails”. Dopo di che abbiamo creato un’istanza per quella classe e accediamo alle proprietà all’interno della classe per assegnare i valori in base alle nostre esigenze.
Quando eseguiamo il programma di cui sopra in swift playground otterremo un risultato come mostrato di seguito
Lo stesso modo in cui possiamo definire e accedere alle proprietà nelle strutture e nelle enumerazioni in base ai nostri requisiti nel linguaggio di programmazione swift.
Abbiamo un diverso tipo di proprietà disponibili nel linguaggio di programmazione swift che sono
- Proprietà memorizzate
- Proprietà calcolate
Proprietà memorizzate swift
In swift la proprietà memorizzata è una costante o variabile ed è memorizzata come parte di un’istanza di una particolare classe o struttura. La proprietà memorizzata può essere usata per memorizzare una variabile con la parola chiave var e una costante con la parola chiave let.
Possiamo fornire un valore di default per una proprietà memorizzata come parte della sua definizione e possiamo modificare i valori iniziali di una proprietà memorizzata durante la sua inizializzazione.
Ora vedremo come definire le proprietà memorizzate nelle classi e come modificare i valori iniziali delle proprietà memorizzate durante la sua inizializzazione con un esempio.
Di seguito è riportato l’esempio di definizione delle proprietà memorizzate come parte di una classe o struttura in un linguaggio di programmazione swift.
struct UserDetails {
var firstName: String = “Rohini”
let lastName: String
}
var uinfo = UserDetails(firstName: “Suresh”, lastName: ” Dasari”)
print(“Nome: \( uinfo.firstName) \(uinfo.lastName)”)
Se osservate l’esempio precedente abbiamo definito due proprietà memorizzate (firstName, lastName) una come variabile (var) e un’altra come costante (let) con valori iniziali. Dopo di che abbiamo creato un’istanza della struttura e modificato i valori iniziali durante la sua inizializzazione.
Quando eseguiamo il programma di cui sopra in swift playground otterremo un risultato come mostrato sotto
Ecco come possiamo definire proprietà memorizzate in classi, strutture, enumerazioni in base alle nostre esigenze nel linguaggio di programmazione swift.
Proprietà memorizzate per istanze di strutture costanti
In swift, possiamo definire una classe o struttura con proprietà memorizzate come una costante. Nel caso in cui definiamo una proprietà costante con un valore iniziale allora non è possibile per noi modificare quel valore perché una volta che il valore assegnato a una variabile costante deve essere lo stesso in tutta l’applicazione.
Nel caso in cui cerchiamo di modificare il valore della proprietà costante durante la sua inizializzazione o con l’istanza di una classe, il compilatore lancerà un errore.
Di seguito è riportato l’esempio di modifica del valore della proprietà costante memorizzato dopo l’inizializzazione del valore durante la creazione dell’istanza della classe.
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)”)
Se osservate l’esempio precedente abbiamo definito una proprietà costante “lastName” e assegnato il valore alla variabile durante la creazione dell’istanza della classe. Dopo di che stiamo ancora cercando di modificare il valore della variabile costante.
Quando proviamo ad eseguire l’esempio sopra in swift playground otterremo un errore come mostrato sotto
Errore: impossibile assegnare alla proprietà: ‘lastName’ è una costante ‘let’
Una volta assegnato un valore alla proprietà costante che dovrebbe essere lo stesso in tutta l’applicazione altrimenti verrà lanciato un errore. Per maggiori informazioni sulle costanti controlla questo Swift Constants.
Swift Lazy Stored Properties
In swift lazy stored property è una proprietà il cui valore iniziale non viene caricato fino alla prima volta che il valore della proprietà viene utilizzato. In swift, possiamo definire una proprietà memorizzata pigra usando la parola chiave lazy prima della sua dichiarazione.
In swift le proprietà memorizzate pigre sono utili quando il valore iniziale della proprietà non deve essere caricato fino a quando viene usato nell’applicazione. Supponiamo di avere una proprietà e abbiamo bisogno di eseguire alcune operazioni complesse per caricare o inizializzare il valore, ma è richiesto solo in luoghi specifici in quel caso se usiamo le proprietà memorizzate pigre quei valori non saranno caricati fino a quando lo usiamo nel nostro codice.
Ora vedremo come utilizzare le proprietà memorizzate pigre nelle applicazioni swift con esempi.
Seguendo è l’esempio di utilizzo delle proprietà memorizzate pigre nel linguaggio di programmazione swift.
classe 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)
Se osservate l’esempio precedente abbiamo definito una proprietà memorizzata pigra “studentInfo” usando la parola chiave lazy. Questo valore di proprietà non verrà caricato fino a quando l’istruzione di stampa non chiamerà la proprietà dall’istanza della classe studente.
Quando eseguiamo il programma sopra in swift playground otterremo un risultato come mostrato di seguito
Questo è il modo in cui possiamo usare le proprietà memorizzate pigre in un linguaggio di programmazione swift basato sui nostri requisiti.
Qui dobbiamo ricordare che sempre abbiamo bisogno di dichiarare le proprietà memorizzate pigre come una variabile (var) perché il suo valore non viene recuperato fino a quando l’inizializzazione dell’istanza non è completata ma per le proprietà costanti (let) devono avere un valore prima che l’inizializzazione sia completata che è la ragione per cui sempre abbiamo bisogno di definire le proprietà pigre come variabili.
Proprietà computerizzate swift
In swift a differenza delle proprietà memorizzate, le proprietà computerizzate non memorizzano un valore, invece le proprietà computerizzate forniscono un getter e un setter opzionale per recuperare e impostare altri valori di proprietà in modo indiretto. Possiamo definire proprietà calcolate in classi, strutture ed enumerazioni in base alle nostre esigenze.
Di seguito è riportato un esempio di definizione di proprietà calcolate utilizzando getter e setter per impostare i valori nel linguaggio di programmazione swift.
class Circle {
var radius : Double?
var cval : Double?
var Area: Double {
get {
return radius! * raggio!
}
set (newArea){
cval = Double(newArea) * 3.14
}
}
}
let result = Circle()
result.Area = 20
print(result.cval)
Se osservate l’esempio precedente stiamo impostando un nuovo valore per la proprietà “Area” usando le proprietà getter e setter.
Quando eseguiamo il programma di cui sopra in swift playground otterremo un risultato come mostrato di seguito
Questo è come possiamo usare le proprietà calcolate in un linguaggio di programmazione swift per utilizzare i valori senza memorizzare in base alle nostre esigenze.
Swift Read-Only Computed Properties
Una proprietà calcolata con solo getter ma nessun setter è conosciuta come una proprietà calcolata in sola lettura. In swift possiamo accedere alle proprietà computerizzate di sola lettura attraverso la sintassi del punto (.) e restituisce sempre un valore.
Di seguito è riportato un esempio di utilizzo delle proprietà computerizzate di sola lettura in un linguaggio di programmazione swift.
classe Moltiplicazione {
var num1 : Int = 5
var num2 : Int = 5
var moltiplicare: Int {
get {
return num1 * num2
}
}
}
let r = Multiplication()
print(r.multiply)
Nell’esempio precedente abbiamo definito due proprietà con valori predefiniti nella classe e moltiplicando questi due numeri usando getter. Dopo di che abbiamo creato un’istanza per la classe e l’accesso al valore del getter usando la sintassi del punto (.).
Quando eseguiamo il programma sopra in swift playground otterremo il risultato come mostrato sotto
Questo è come possiamo usare le proprietà calcolate in sola lettura per impostare i valori usando la proprietà getter nel linguaggio di programmazione swift.
Swift Property Observer
In swift gli osservatori di proprietà sono usati per osservare e rispondere ai cambiamenti nel valore della proprietà e questi osservatori di proprietà chiameranno ogni volta che il valore della proprietà cambia, anche se il nuovo valore della proprietà è uguale al valore corrente.
In swift, i cambiamenti nelle proprietà possono essere osservati utilizzando i seguenti due osservatori.
- willSet – Questo osservatore viene chiamato appena prima che il valore venga memorizzato.
- didSet – Questo è un osservatore viene chiamato dopo che il nuovo valore viene memorizzato.
In swift, possiamo utilizzare gli osservatori di proprietà in qualsiasi proprietà memorizzata, tranne le proprietà memorizzate pigre.
Segue l’esempio dell’uso delle proprietà willSet e didSet in un linguaggio di programmazione swift.
classe Modifiche {
var num1: Int = 10 {
willSet(newvalue) {
print(“Valore di \(newvalue)”)
}
didSet {
if num1 > oldValue {
print(“Aggiunto \(num1 – oldValue)”)
}
}
}
}
let result = Changes()
result.num1 = 34
result.num1 = 987
Se osservate l’esempio precedente abbiamo usato gli osservatori willSet e didSet e queste proprietà sono chiamate ogni volta che il valore della proprietà viene cambiato.
Quando eseguiamo il programma di cui sopra in swift playground otterremo il risultato come mostrato di seguito
Valore di 34
Aggiunto 24
Valore di 987
Aggiunto 953
Swift Proprietà di tipo
In swift, le proprietà di istanza sono associate a un’istanza di classe o struttura, le proprietà di tipo sono associate a un tipo stesso, non appartiene a nessuna istanza del tipo.
In swift, possiamo definire una proprietà di tipo con la parola chiave static e per le proprietà di tipo calcolate e per i tipi di classe dobbiamo usare la parola chiave class ma non permetterà di sovrascrivere i metodi o le variabili della superclasse.
Segue l’esempio dell’uso delle proprietà di tipo nel linguaggio di programmazione 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()
Se osservate l’esempio precedente abbiamo definito una proprietà di tipo con la parola chiave static e accediamo ai valori delle proprietà di tipo facendo riferimento al nome e usando la sintassi dei punti per accedere al valore.
Quando eseguiamo il programma sopra nel linguaggio di programmazione swift otterremo il risultato come mostrato sotto.
Swift interroga e imposta le proprietà del tipo
In swift, le proprietà del tipo vengono interrogate e possiamo quindi impostare il valore con la sintassi dei punti (.) proprio come quando creiamo un’istanza e assegniamo i valori alle proprietà. Tuttavia, le proprietà del tipo vengono interrogate e impostano il valore delle proprietà sul tipo, non su un’istanza di quel tipo.
Di seguito è riportato l’esempio di utilizzo delle proprietà del tipo nel linguaggio di programmazione swift.
struct typerepo {
static var msg = “Welcome”
}
print(typerepo.msg)
typerepo.msg = “Welcome to Tutlane”
print(typerepo.msg)
Se osservate l’esempio precedente abbiamo creato la proprietà type e impostato il valore direttamente usando un’istanza di quel tipo.