Estructuras y clases
Las estructuras y las clases son dos de los bloques de construcción principales de la programación en Swift. Ambas son formas de agrupar datos y funciones relacionados en unidades de funcionalidad autocontenidas. Y cuando defines una estructura o una clase, estás definiendo un nuevo tipo que se usará en Swift, igual que usaste los tipos con los que ya has trabajado, como Int y String.
Hay muchas similitudes entre las estructuras y las clases en Swift. Entre otras similitudes, ambas pueden almacenar valores en propiedades y proporcionar funcionalidad mediante el uso de métodos.
Cada una proporciona funcionalidad adicional, que queda fuera del alcance de este ejercicio.
Definir estructuras y clases
Tanto las estructuras como las clases se definen de forma similar. Comienzan con la palabra clave adecuada seguida del nombre del tipo que se está definiendo; después sigue el cuerpo de la estructura o clase, colocado entre llaves.
El cuerpo puede constar de propiedades almacenadas, que se definen y se comportan igual que las constantes o variables normales.
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()
}
Instancias
Como se ha indicado antes, definir una estructura o una clase es solo definir un nuevo tipo. Es solo el plano de cómo serán los valores de ese tipo, pero no crea ningún valor de ese tipo con el que puedas trabajar.
Para crear una instancia de ese tipo, debes escribir el nombre del tipo seguido de un par de paréntesis.
let someStats = CharacterStats()
let someCharacter = GameCharacter()
Esto creará valores de estos tipos, donde las propiedades se rellenan con los valores predeterminados proporcionados en la definición. Ten en cuenta que, en casos opcionales como la propiedad name de GameCharacter, a menos que se proporcione un valor, la propiedad será nil de forma predeterminada, igual que al definir tipos opcionales normales en los que no se proporciona un valor de inmediato.
Con las estructuras, Swift proporciona automáticamente algo llamado inicializador por miembros, donde los valores para las propiedades de la estructura se pueden proporcionar dentro de los paréntesis, lo que anulará los valores predeterminados de la definición.
let differentStats = CharacterStats(health: 100.0, speed: 6, strength: 18)
Acceder a las propiedades
Se puede acceder a las propiedades de estructuras y clases mediante la notación de punto, donde el nombre del valor va seguido de un punto (.) y el nombre de la propiedad. Si una propiedad de una estructura o clase tiene propiedades propias, esta notación de punto también puede usarse para acceder a esas propiedades anidadas.
Esta notación puede usarse tanto para obtener el valor de la propiedad como, cuando esté permitido, para cambiarlo.
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
Métodos
Al igual que las propiedades, que almacenan datos en tus estructuras y clases, también puedes definir métodos que almacenan funciones en tu estructura o clase.
Los métodos se definen igual que una función normal, solo que dentro del cuerpo de la estructura o clase. Ten en cuenta que, si una función cambia el valor de una propiedad en una estructura, debe ir precedida de la palabra clave mutating. Además, si un método puede cambiar una propiedad, esa propiedad debe definirse con var en lugar de let, igual que las variables normales.
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."
}
}
}
Se puede llamar a estos métodos usando la notación de punto, igual que con las propiedades.
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
Cada instancia de una estructura o clase tiene una propiedad implícita llamada self, que se refiere a la instancia misma.
El uso más común de self es desambiguar entre una propiedad de instancia y un parámetro que comparte el mismo nombre:
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
}
}
Los tipos de Swift también proporcionan una palabra clave Self con mayúscula, que se refiere al tipo de la instancia en lugar de a la instancia misma.
Ejercicio de aprendizaje
