Struct e classi
Le struct e le classi sono due dei principali elementi costitutivi della programmazione in Swift. Entrambe sono un modo per raggruppare dati e funzioni correlate in unità di funzionalità autonome. E quando definisci una struct o una classe, stai definendo un nuovo tipo da usare in Swift, proprio come hai usato i tipi con cui hai già lavorato, come Int e String.
Ci sono molte somiglianze tra struct e classi in Swift. Tra le altre cose, entrambe sono in grado di memorizzare valori in proprietà e di offrire funzionalità tramite l'uso di metodi.
Ognuna fornisce anche funzionalità aggiuntive, che esulano da questo esercizio.
Definire struct e classi
Sia le struct sia le classi si definiscono più o meno allo stesso modo. Si inizia con la parola chiave appropriata seguita dal nome del tipo che si sta definendo, poi segue il corpo della struct o della classe, racchiuso tra parentesi graffe.
Il corpo può essere formato da proprietà memorizzate, che si definiscono e si comportano proprio come normali costanti o variabili.
struct CharacterStats {
var health = 0.0
var speed = 0
var strength = 0
}
class GameCharacter {
var stats = CharacterStats()
var characterClass: String?
var name: String?
var active = false
let id = makeRandomID()
}
Istanze
Come detto sopra, definire una struct o una classe significa semplicemente definire un nuovo tipo. È soltanto il progetto di come saranno i valori di quel tipo, ma non crea davvero alcun valore di quel tipo con cui lavorare.
Per creare un'istanza di quel tipo, devi scrivere il nome del tipo seguito da una coppia di parentesi tonde (()).
let someStats = CharacterStats()
let someCharacter = GameCharacter()
Questo creerà valori di questi tipi, con le proprietà popolate con i valori predefiniti forniti nella definizione. Nota che nei casi opzionali come la proprietà name di GameCharacter, se non viene fornito un valore, la proprietà sarà nil per impostazione predefinita, proprio come quando si definiscono normali tipi opzionali in cui non viene fornito subito un valore.
Con le struct, Swift fornisce automaticamente qualcosa chiamato inizializzatore memberwise, in cui i valori per le proprietà della struct possono essere forniti tra parentesi tonde, sovrascrivendo i valori predefiniti della definizione.
let differentStats = CharacterStats(health: 100.0, speed: 6, strength: 18)
Accedere alle proprietà
Si può accedere alle proprietà di struct e classi usando la notazione a punto, in cui il nome del valore è seguito da un punto (.) e dal nome della proprietà. Se una proprietà di una struct o di una classe ha proprietà proprie, questa notazione a punto può essere usata per accedere anche a queste proprietà annidate.
Questa notazione può essere usata sia per recuperare il valore della proprietà sia, dove consentito, per modificarlo.
someStats.health
// => 0
someCharacter.name
// => nil
someStats.health = 87.3
someStats.health
// => 87.3
someCharacter.name = "Luther"
someCharacter.name
// => "Luther"
someCharacter.id = "new id"
// Error: Cannot assign to property: 'id' is a 'let' constant
Metodi
Come le proprietà, che memorizzano dati nelle struct e nelle classi, puoi anche definire metodi, che memorizzano funzioni nella struct o nella classe.
I metodi si definiscono allo stesso modo di una normale funzione, solo all'interno del corpo della struct o della classe. Nota che se una funzione cambia il valore di una proprietà in una struct, deve essere preceduta dalla parola chiave mutating. Inoltre, se una proprietà può essere modificata da un metodo, quella proprietà deve essere definita con var invece che con let, proprio come le normali variabili.
struct CharacterStats {
var health = 0.0
var speed = 0
var strength = 0
mutating func takeHit(_ damage: Double) {
health = max(0.0, health - damage)
}
func canLift(_ weight: Int) -> Bool {
weight < strength * 100
}
}
class GameCharacter {
var stats = CharacterStats()
var characterClass: String?
var name: String?
var active = false
let id: String = makeRandomID()
func takesDamage(_ damage: Double) {
stats.takeHit(damage)
if stats.health <= 0 {
active = false
}
}
func sayName() -> String {
return "My name is \(name ?? "no one"), my class is \(characterClass ?? "undetermined")"
}
func lift(_ weight: Int) -> String {
if stats.canLift(weight) {
return "No problem!"
} else {
return "Ooof! No way."
}
}
}
Questi metodi possono essere chiamati con la notazione a punto, proprio come le proprietà.
var myChar = GameCharacter()
myChar.stats = CharacterStats(health: 72.8, speed: 19, strength: 6)
myChar.active = true
myChar.lift(750)
// => "Ooof! No way."
myChar.takesDamage(80)
myChar.active
// => false
Self
Ogni istanza di una struct o di una classe ha una proprietà implicita chiamata self, che si riferisce all'istanza stessa.
L'uso più comune di self è disambiguare tra una proprietà dell'istanza e un parametro che ha lo stesso nome:
struct Position {
var x = 0
mutating func move(x: Int) {
// Here, 'self.x' refers to the struct's property,
// while 'x' refers to the parameter passed to the method.
self.x = x
}
}
Anche i tipi di Swift forniscono una parola chiave Self con l'iniziale maiuscola, che si riferisce al tipo dell'istanza invece che all'istanza stessa.
Esercizio di apprendimento
