Variables de solo lectura en programación y su uso en estructuras y clases

Clase 8 de 27 • Curso de Programación Orientada a Objetos en Swift

Resumen

¿Qué son las variables de solo lectura?

Las variables de solo lectura son un tipo especial de propiedad computada que permite obtener un valor pero no modificarlo. Imagina que están diseñadas para proteger ciertos datos críticos en tu estructura o clase, donde el cálculo o uso de un valor debe mantenerse constante. Un ejemplo clásico es el cálculo del volumen de un cubo a partir de sus dimensiones.

¿Cómo se implementan las propiedades computadas de solo lectura?

Para implementar una Computer Property de solo lectura en Swift, no es necesario indicar explícitamente las palabras get o set dentro de la propiedad. Simplemente calcula y devuelve el valor, asegurando que la propiedad sea consultable pero inmodificable, protegiendo así la integridad de los datos. Observa cómo definimos una estructura para un cubo y calculamos su volumen:

struct Cubo {
    var anchura: Double = 0.0
    var altura: Double = 0.0
    var profundidad: Double = 0.0

    var volumen: Double {
        return anchura * altura * profundidad
    }
}

let cubo = Cubo(anchura: 4, altura: 5, profundidad: 2)
print(cubo.volumen) // Output: 40

¿Qué sucede si intento modificar una propiedad de solo lectura?

Swift protege las propiedades de solo lectura impidiendo que se asignen nuevos valores. Si intentas modificar una propiedad de solo lectura, el compilador señalará un error. Esto es porque dichas propiedades están diseñadas para mantenerse inalteradas, asegurando que el cálculo o el uso del valor corresponda siempre a una lógica específica y controlada únicamente por el propietario de la clase o estructura.

// Intento incorrecto de asignación
// cubo.volumen = 57
// Error: la propiedad `volumen` es de solo lectura

¿En qué situaciones son útiles las variables de solo lectura?

Las variables de solo lectura son especialmente valiosas cuando:

Quieres proteger un cálculo crítico derivado de otros valores.
Deseas evitar que un programa externo altera propiedades críticas de una estructura o clase.
Buscas claridad y precisión, calculando propiedades derivadas sin permitir cambios manuales inapropiados.

Ejercicios y prácticas recomendadas

Te recomendamos explorar cómo podrías crear tus propias estructuras o clases incorporando propiedades computadas. ¿Qué tal si defines una estructura para un saludo que varíe según el género, la persona y el idioma? Usa las propiedades computadas para hacer que tu código sea más robusto y fácil de mantener.

Intenta sintetizar los conceptos aquí tratados al crear una clase o estructura con propiedades computadas de solo lectura en Swift, y comparte tus ejercicios en el foro del curso para retroalimentación y mejoras continuas. ¡Ánimo y sigue desarrollando tus habilidades de programación!

Wilson Montenegro

student•

enum Languaje {
    case Spanish, English, French
}
enum Gender{
    case male, female
}
struct Person{
    var name: String
}
struct Gretting{
    var person: Person
    var languaje: Languaje
    var gender: Gender
    var languajeGretting: String{
            switch self.languaje {
            case Languaje.Spanish:
                return "Hola "
            case Languaje.English:
                return "Hello "
            case Languaje.French:
                return "Salut "
        }
    
    }
    var abbreviations: String{
            switch self.gender {
            case Gender.male:
                return languajeGretting + "Mr. \(person.name)"
            case Gender.female:
                return languajeGretting + "Mrs. \(person.name)"
        }
    }
}

let guest = Person(name: "Juana")
let welcomeGretting = Gretting(person: guest, languaje: .French, gender: .female)
welcomeGretting.abbreviations

Luis Abdel Rangel Castro

student•

struct Person {
    var firstName : String
    var lastName : String
    var name : String {
        firstName + " " + lastName
    }
}

var persona = Person(firstName: "Luis", lastName: "Rangel")
print(persona.name)

Bradley Robertson Cardenas Alcocer

student•

Yo hice esto. Hice una estructura de una persona. Tiene como propiedades: nombre, idioma que habla, genero, saludo, y una presentación

struct Person{
    var name: String
    var gender: Gender
    var language: String
    var greeting: String {
        switch language {
        case "french":
            return "bonjour"
        case "spanish":
            return "hola"
        case "english":
            return "hello"
        default:
            return "I'm sorry, y can't greeting you"
        }
    }
    var presentation: String{
        var title = ""
        if gender == Gender.man{
            title = "Mr. "
        }else {title = "Mrs. "}
        
        return title + name + " says " + greeting
    }
}

var Bradley = Person(name: "Bradley", gender: Gender.man, language: "french")

Cristian Pisco Intriago

student•

enum Language{
    case Spanish, English, French
}
struct Person{
    var name : String
}
struct Greet{
    var language : Language
    var person: Person
    var greeting: String {
        switch self.language {
        case .Spanish:
            return "Hola \(person.name)"
        case .English:
            return "Hello \(person.name)"
        case .French:
            return "Salut \(person.name)"
        }
    }
}
let person = Person(name: "Cristian")
let greet = Greet(language: .French, person: person)
greet.greeting

Cristian Daniel Ramirez Caro

student•

struct Greeting{
    var lenguage = String()
    var gender = String()
    var name = String()
    
    var menssage: String {
        return initialGreeting + name
    }
    
    var initialGreeting: String {
        switch lenguage{
        case &quot;spanish&quot;:
            let aux = &quot;Hola &quot;
            if gender == &quot;Female&quot; {
                return aux + &quot;Señora &quot;
            }
            return aux + &quot;Señor &quot;
        case &quot;english&quot;:
            let aux = &quot;Hello &quot;
            if gender == &quot;Female&quot; {
                return aux + &quot;Lady &quot;
            }
            return aux + &quot;Gentleman &quot;
        case &quot;French&quot;:
            let aux = &quot;Bonjour&quot;
            if gender == &quot;Female&quot; {
                return aux + &quot;Madame &quot;
            }
            return aux + &quot;Monsieur &quot;
        default:
            return &quot;Hi &quot;
        }
    }
}

let greeting = Greeting(lenguage: &quot;english&quot;, gender: &quot;male&quot;, name: &quot;Omar&quot;)
greeting.menssage

Gerardo Estrella

student•

Las Computed Properties de sólo lectura en Swift son propiedades que calculan su valor a partir de otras propiedades, pero no permiten ser modificadas directamente. Esto es útil para garantizar la integridad de los datos.

Ejemplos:

Cubo:

struct Cubo {
    var ancho: Double
    var alto: Double
    var profundo: Double
    
    var volumen: Double {
        return ancho * alto * profundo
    }
}

Círculo:

struct Circulo {
    var radio: Double
    
    var area: Double {
        return Double.pi * radio * radio
    }
}

En estos ejemplos, volumen y area son propiedades de sólo lectura que se calculan a partir de otras propiedades.

Alejandro Ivan Mendieta

student•

Acá mi ejercicio

//Ejercicio persona que saluda

enum Language{
    case japanese
    case inglés
    case español
}

enum Gender{
    case masculino
    case femenino
}

struct Person{
    var name:String
}

class Greetings{
    private var languaje:Language
    private var gender:Gender
    private var person:Person
    private var greeting:String{
        get {
            switch self.languaje {
            case .japanese:
                if(isFemale(gender:self.gender)){
                    return "Konichiwa \(self.person.name) san"
                }else{
                    return "Konichiwa \(self.person.name) kun"
                }
            case .inglés:
                if(isFemale(gender:self.gender)){
                    return "Hello lady \(self.person.name)"
                }else{
                    return "Hello Sr. \(self.person.name)"
                }
            case .español:
                if(isFemale(gender:self.gender)){
                    return "Hola señorita \(self.person.name)"
                }else{
                    return "Hola joven \(self.person.name)"
                }
            }
        }
    }
    
    public init(languaje: Language, gender: Gender,person: Person) {
        self.languaje = languaje
        self.gender = gender
        self.person = person
    }
    
    public func greetingPerson () -> String {
        return self.greeting
    }
    
    private func isFemale(gender:Gender) -> Bool{
        switch gender {
        case .femenino:
            return true
        default:
            return false
        }
    }

}


var madai = Greetings(languaje: .español, gender: .femenino, person: Person(name:"Claudia Madai"))

print(madai.greetingPerson())

Diego Alejandro Seitler

student•

enum Genders {
case male, female, undefined
}

enum Languages {
case Spanish, English, Portugues
}

struct Name {
    var name: String
}

struct Greeting {
    var name: Name
    var language: Languages
    var gender: Genders
    var greet : String {
        switch self.language {
        case .Spanish:
            return "Hola"
        case .English:
            return "Hello"
        case .Portugues:
            return "Ola"
        }
    }
    var title: String{
        switch self.gender {
        case .male:
            "Mr \(name.name)"
        case .female:
            "Mrs \(name.name)"
        case .undefined:
            "\(name.name)"
        }
    }
}

var greetMale = Greeting(name: Name(name: "Diego"), language: .Spanish, gender: .male)
print("\(greetMale.greet) \(greetMale.title)")

var guest2 = Name(name: "Sofia")
var greetFemale = Greeting(name: guest2, language: .English, gender: .female)
print("\(greetFemale.greet) \(greetFemale.title)")

var guest3 = Name(name: "Teodoro")
var greetUndefined = Greeting(name: guest3, language: .Portugues, gender: .undefined)
print("\(greetUndefined.greet) \(greetUndefined.title)")

Edwin Garcés Saucedo

student•


**enum** Language {

**case** spanish, english, french

}



**enum** Gender {

**case** male, female

}



**struct** Greet {

**var** name = "", lastname = ""

**var** language: Language

**var** genre: Gender

**var** greetings: String {

**return** (

language == .english ? "Hello, " : (language == .spanish ? "Hola, " : "Bonjour, "))

\+ (genre == .male ? "Sr. " : "Sra. ")

\+ name

\+ " "

\+ lastname

}

}



**var** greet = Greet(name: "Edwin", lastname: "Garcés", language: .spanish, genre: .male)

greet.greetings

"Hola, Sr. Edwin Garcés"

Edwin Garcés Saucedo

student•

enum`` Language {

case`` spanish, english, french

}

enum`` Gender {

case`` male, female

}

struct`` Greet {

var`` name = "", lastname = ""

var`` language: Language

var`` genre: Gender

var`` greetings: String {

return`` (

language == .english ? "Hello, " : (language == .spanish ? "Hola, " : "Bonjour, "))

+ (genre == .male ? "Sr. " : "Sra. ")

+ name

+ " "

+ lastname

}

var`` greet = Greet(name: "Edwin", lastname: "Garcés", language: .spanish, genre: .male)

greet.greetings

// "Hola, Sr. Edwin Garcés"

Luis Garay

student•

El ejemplo que hice fue una bascula. Calcula el precio total de la compra de un vegetal dependiendo de las libras que lleves del mismo. Por otra parte, también permite calcular cuantas libras del vegetal puedes llevar por cierta cantidad de dinero.

struct VegetablePrice {
    var vegetable : Vegetables
    var poundsToShop = 0.0
    var totalPrice:Double{
        get{
            switch vegetable{
            case .onion:
                let pricePerPound = 3.0
                return pricePerPound * poundsToShop
            case .carrot:
                let pricePerPound = 4.0
                return pricePerPound * poundsToShop
            case .peas:
                let pricePerPound = 1.5
                return pricePerPound * poundsToShop
            }
        }
        set{
            let pricePerPound = (totalPrice/poundsToShop)
            poundsToShop = newValue/pricePerPound
        }
    }
}

var shop1 = VegetablePrice(vegetable: .carrot, poundsToShop: 3)
shop1.totalPrice
let oldValue = shop1.totalPrice
shop1.totalPrice = 40
shop1.poundsToShop

Diego Urrego

student•

Comparto mi ejercicio a continuación

// Ejercicio:
enum Lenguage {
    case spanish, english, chinese
}

enum Gender {
    case female, male, nonBinary
}

struct Person {
    var name: String
    var lenguage: Lenguage
    var gender: Gender
    
    var greeting: String {
        get {
            switch (self.lenguage, self.gender) {
            case (.spanish, .male):
                return "Bienvenido señor \(name)"
            case (.spanish, .female):
                return "Bienvenida señora \(name)"
            case (.spanish, .nonBinary):
                return "Por favor, acompañeme"
            case (.english, .male):
                return "Welcome, Mr. \(name)"
            case (.english, .female):
                return "Welcome, Mrs. \(name)"
            case (.english, .nonBinary):
                return "Please, come with me"
            case (.chinese, .male):
                return "欢迎，先生 \(name)"
            case (.chinese, .female):
                return "欢迎，女士 \(name)"
            case (.chinese, .nonBinary):
                return "请跟我来"
            }
        }
    }

}

var person101 = Person(name: "Diego", lenguage: .spanish, gender: .male)
var person102 = Person(name: "Terrese", lenguage: .english, gender: .female)
var person103 = Person(name: "Azul", lenguage: .chinese, gender: .nonBinary)

person101.greeting
person102.greeting
person103.greeting

Jessica Balanta Restrepo

student•

:) struct Person { var name: String var genre: Genre var language: Language

var grettings: String {
    switch language {
    case .español:
        if genre == .man {
            return "Hola Señor \(name)"
        }else {
            return "Hola Señorita \(name)"
        }
    case .frances:
        if genre == .man {
            return "Bonjour Monsier \(name)"
        }else {
            return "Bonjour Mademoiselle\(name)"
        }
    case .ingles:
        if genre == .man {
            return "Good morning Sr. \(name)"
        }else {
            return "Good morning Miss \(name)"
        }
    }
}

}

enum Genre { case man case woman } enum Language { case ingles case frances case español }

Jairo Toro

student•

Se que está muy vago, lo ideal sería con un enum limitar la cantidad de valores que podría tomar lenguaje y gender pero bueno. Ahí está mi ejemplo.

struct Saludo {
    var name = ""
    var gender = ""
    var languaje = ""
    var saludar: String {
        get {
            if (languaje == "espanol" && gender == "male") {
                return "Hola senor \(name)"
            }
            if (languaje == "espanol" && gender == "female") {
                return "Hola senora \(name)"
            }
            return "no ppuedo saludar"
        }
    }
}

let primerSaludo = Saludo(name: "Jairo", gender: "male", languaje: "espanol")
primerSaludo.saludar

Ulises Serrano Pérez

student•

Yo hice este ejemplo.

struct Person{
    var firstName: String
    var lastName: String
    var yearOfBirthday: Int
    var age: Int{
        Calendar.current.component(.year, from: Date()) - yearOfBirthday
    }
    var hasIne: Bool{
        age > 18 ? true : false
    }
}

var ulises = Person(firstName: "Ulises", lastName: "Serrano", yearOfBirthday: 1993)
ulises.age
ulises.hasIne

var veronica = Person(firstName: "Veronica", lastName: "Teoyotl", yearOfBirthday: 2009)
veronica.age
veronica.hasIne

Andy Antonio Paz Cambara

student•

También pude crear este pequeño código

struct Persona {
    var name : String
    var lastName : String
    var yearOfBirth : Int
}

struct edad{
    var persona: Persona
    var edad : Int {
        return 2022 - persona.yearOfBirth
    }
}

let Andy = edad(persona: Persona(name: "andy", lastName: "Paz", yearOfBirth: 2000))
let Luis = edad(persona: Persona(name: "Luis", lastName: "Paz", yearOfBirth: 2002))
let David = edad(persona: Persona(name: "David", lastName: "Flowrez", yearOfBirth: 2015))


print("Hola \(Andy.persona.name) \(Andy.persona.lastName) tu edad actual es: \(Andy.edad)")
print("Hola \(Luis.persona.name) \(Luis.persona.lastName) tu edad actual es: \(Luis.edad)")
print("Hola \(David.persona.name) \(David.persona.lastName) tu edad actual es: \(David.edad)")

Andy Antonio Paz Cambara

student•

enum lenguajes {
    case español, ingles, frances
}

enum generos {
    case hombre, mujer, sinGenero
}

struct persona {
    var nombre : String
    var apellido : String

}

struct saludo {
    var lenguaje : lenguajes
    var genero : generos
    var Humano : persona
    
    var saludo : String{
        switch lenguaje{
        case .español:
            return "hola \(Humano.nombre) "
        case .ingles:
            return "hi \(Humano.nombre)"
        case.frances:
            return "bongiu \(Humano.nombre)"
        }
    }
}


let saludoPersona = saludo(lenguaje: .ingles, genero: .hombre, Humano: persona(nombre: "andy", apellido: "Paz"))
print(saludoPersona.saludo)

Miguel Angel Castañeda Balleza

student•

class PCPrice {
    var keyboard = 0.0, mouse = 0.0, display = 0.0, pc = 0.0
    var price:Double {
        return keyboard + mouse + display + pc
    }
}

let myPC = PCPrice()
myPC.keyboard = 10.0
myPC.mouse = 5.0
myPC.display = 100.0
myPC.pc = 150.0
myPC.price

Emmanuel Guerra Sánchez

student•

class NumbersCalculator {
    var nums = [Int]()
    
    var sum: Int {
        nums.reduce(0) { x, y in x + y }
    }
    
    var substract: Int {
        nums.reduce(0) { x, y in x - y }
    }
    
    var product: Int {
        nums.reduce(1) { x, y in x * y }
    }
    
    var division: Int {
        nums.reduce(1) { x, y in
            if x == 0 {
                return x
            } else if y == 0 {
                return y
            } else {
                return y / x
            }
        }
    }
}

Michael Chavarría

student•

enum Language {
    case Spanish, English
}
enum Gender {
    case Male, Female
}
struct Greet{
    var personName: String
    var language: Language
    var gender: Gender
    var greeting: String {
        switch self.language {
            case .Spanish:
                return "Hola"
            case .English:
                return "Hello"
        }
    }
    var genderPresentation: String {
        switch self.gender {
            case .Male:
                return self.language == Language.English ? "Mr." : "Sr."
            case .Female:
                return self.language == Language.English ? "Mrs." : "Sra."
        }
    }
    var to: String {
        return "\(greeting), \(genderPresentation) \(personName)"
    }
}
let greet = Greet(personName: "Michael", language: Language.English, gender: Gender.Male)
print("\(greet.to)")