Cursos Empresas Blog Live Conf Eventos Precios

0:005:14

Recursos

Resumen

Domina cómo y cuándo usar propiedades computadas de solo lectura en Swift. Verás por qué un valor derivado no debe modificarse directamente, cómo declarar el getter implícito y un ejemplo práctico: el volumen de un cuboide. Además, se aclara su uso tanto en structs como en classes y se propone un ejercicio aplicado.

¿Qué es una computed property de solo lectura en Swift?

Una variable es de solo lectura cuando no tiene setter y solo tiene getter. Es decir, su valor se calcula a partir de otros datos y no se puede asignar desde fuera. Esto evita inconsistencias: si alguien cambiara el volumen, no habría forma clara de saber cómo ajustar anchura, altura o profundidad.

Valor derivado: se calcula con otros campos internos.
Sin setter: no admite asignaciones externas.
Coherencia de datos: impide cambios ambiguos.

¿Cómo se declara un getter implícito en Swift?

Swift permite omitir la palabra clave get en una computed property de solo lectura. El cuerpo entre llaves define la expresión calculada.

Sintaxis concisa: var propiedad: Tipo { expresión }.
Claro y seguro: comunica que no hay setter.

¿Qué pasa si intentas modificar una read-only property?

Si intentas asignar un nuevo valor, Swift marca error: no se puede asignar una propiedad de solo lectura. El valor solo se consulta, no se modifica.

¿Cómo calcular el volumen de un cuboide con una computed property?

Se define un cuboide con anchura, altura y profundidad. El volumen es el producto de esas tres magnitudes. Aquí, lo correcto es exponerlo como propiedad computada de solo lectura.

struct Cuboid {
    var width: Double = 0.0
    var height: Double = 0.0
    var depth: Double = 0.0

    // Computed property de solo lectura
    var volume: Double {
        width * height * depth
    }
}

let cuboid = Cuboid(width: 4, height: 5, depth: 2)
let v = cuboid.volume  // 40

// cuboid.volume = 57  // Error: propiedad de solo lectura.

width, height, depth: propiedades almacenadas que se pueden editar.
volume: propiedad computada sin setter, solo obtiene el valor.
Intento de asignación: produce error por ser de solo lectura.

¿Por qué el volumen no aparece como editable?

Al inspeccionar la instancia ves las propiedades almacenadas (anchura, altura, profundidad). El volumen solo se expone para consulta, no como campo asignable. Esto refuerza la idea de valor derivado.

¿Se usan en structs y en classes en Swift?

Sí. Aunque el ejemplo se mostró con struct, las propiedades computadas, las propiedades almacenadas y las propiedades perezosas también aplican a las classes. No te limites mentalmente a las estructuras: el patrón sirve en ambos tipos.

Reutilizable: mismo patrón en structs y classes.
Encapsulación: calcula internamente valores derivados.
API clara: evita exponer asignaciones incoherentes.

¿Cómo practicar con un saludo dinámico?

Se sugiere crear una estructura con género, idioma y nombre. La computed property construye el saludo según esos datos, por ejemplo, diciendo "Hola", "Hello" o "Bonjour" y añadiendo el nombre.

struct Saludo {
    var genero: String    // "femenino" o "masculino"
    var idioma: String    // "es", "en", "fr"
    var nombre: String

    var saludo: String {
        let base: String
        switch idioma {
        case "es": base = "Hola"
        case "en": base = "Hello"
        case "fr": base = "Bonjour"
        default: base = "Hola"
        }
        return "\(base), \(nombre)"
    }
}

Combina datos: idioma y nombre generan el mensaje.
Evita setter: el saludo se deriva del estado.
Extensible: puedes ajustar reglas por género cuando lo necesites.

¿Tienes otra idea de computed property útil en tu código? Comparte tu propuesta y cómo la implementarías.

Computed properties de solo lectura en Swift

Curso de Programación Orientada a Objetos en Swift

Clase 8 de 27

Clase 8 / 27

Comentarios (32)32 comentarios

Wilson Montenegro

Hace 7 años

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

Hace 6 años

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

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

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

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

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

Marlon Steven Diaz Lopez

Hace 5 meses

Ejemplo con temperatura

// HOMEWORK - EXAMPLE
struct Temperature {
    var celsius: Double
    var fahrenheit: Double {
        celsius * 9 / 5 + 32
    }
    
    var description: String {
        switch celsius {
          case ..<0:
              return "Below Zero"
          case 0..<15:
              return "Cold"
          case 15..<28:
              return "Warm"
          default:
              return "Hot"
        }
    }
}

let temp = Temperature(celsius: 22)
temp.fahrenheit // 71.6
temp.description // "Warm"

// Error
// temp.fahrenheit = 100

León Salas

Hace 5 meses•editado

struct Point{

var x: Double

var y: Double

}

struct Weapon {

var weapon: String

var scale: Double

struct DMG {

var Location = Point(x: -73.985130, y: 40.758896)

var weapon = Weapon(weapon: "Meteor Launcher", scale: 10.0)

var DMG: Double{

get {

let damage = pow(weapon.scale, weapon.scale)

return damage

var Calculated = DMG()

Calculated.weapon.scale = 1.0

Calculated.weapon.weapon = "Rain maker"

Calculated.Location.x = -2.246111

Calculated.Location.y = 22.2511

print(Calculated.DMG)

Kevin Niño guerrero

Hace 7 meses

Carlos Rey

Hace 10 meses

enum Gender {
    case masculino, femenino
}
enum Language {
    case spanish, english
}

struct Saludo{
    var name:String
    var gender:Gender
    var language:Language
    var saludar:String{
        if self.language == Language.spanish{
            if self.gender == Gender.masculino {
                return ("Hey \(self.name) Tas Fuerte we")
            }else{
                return("Hola \(self.name) Te ves bien")
            }
        }
        if self.language == Language.english{
            if self.gender == Gender.masculino {
                return("Hey \(self.name) You looks Strong man")
            }else{
                return("Hello \(self.name) You looks cute")
            }
           
        }else{
            return("No language defined")
        }
        
       
    }
}

let saludo = Saludo(name: "Carlos", gender: Gender.femenino, language: Language.english)
saludo.saludar

Gerardo Estrella

Hace 2 años

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

Diego Alejandro Seitler

Edwin Garcés Saucedo

Hace 3 años


**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"

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

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

Jessica Balanta Restrepo

Hace 4 años

:) 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

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

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

Hace 5 años

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)")

Recursos

Resumen

Computed properties de solo lectura en Swift

Progreso del curso

Estructuras y Clases

Tipos de Propiedades

Métodos, subíndices y herencia

Inicializadores o constructores

Encadenamiento opcional

Conclusión