Estructuras y clases
Las estructuras y las clases son dos de los bloques fundamentales 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 tipo nuevo que se usará en Swift, tal como usaste los tipos con los que ya trabajaste, como Int y String.
Hay muchas similitudes entre las estructuras y las clases en Swift. Entre otras, ambas pueden almacenar valores en propiedades y ofrecer funcionalidad mediante el uso de métodos.
Cada una ofrece funcionalidad adicional, que queda fuera del alcance de este ejercicio.
Definir estructuras y clases
Tanto las estructuras como las clases se definen más o menos de la misma manera. Empiezan con la palabra clave correspondiente, seguida del nombre del tipo que se está definiendo; después viene el cuerpo de la estructura o la clase, entre llaves.
El cuerpo puede estar formado por propiedades almacenadas, que se definen y se comportan igual que una constante o una variable 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 mencionó antes, definir una estructura o una clase es solo definir un tipo nuevo. Es solo el plano de cómo se verán los valores de ese tipo, pero en realidad no crea ningún valor de ese tipo para que trabajes con él.
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, con las propiedades inicializadas con los valores predeterminados que se indican en la definición. Ten en cuenta que, en casos opcionales como la propiedad name de GameCharacter, si no se proporciona un valor, la propiedad toma el valor nil de forma predeterminada, igual que cuando defines 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, en el que puedes indicar valores para las propiedades de la estructura dentro de los paréntesis, lo que sobrescribe 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 usando la notación de punto, en la que el nombre del valor va seguido de un punto (.) y del nombre de la propiedad. Si una propiedad de una estructura o de una clase tiene propiedades propias, también puedes usar esta notación de punto para acceder a esas propiedades anidadas.
Puedes usar esta notación 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
Así como las propiedades 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 la clase. Ten en cuenta que, si una función cambia el valor de una propiedad de 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."
}
}
}
Puedes 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 una clase tiene una propiedad implícita llamada self, que hace referencia a la instancia misma.
El uso más común de self es distinguir entre una propiedad de la instancia y un parámetro que tiene 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 ofrecen una palabra clave Self con mayúscula inicial, que hace referencia al tipo de la instancia en lugar de a la instancia misma.
Ejercicio de aprendizaje
