Swift – Propiedades y sus Diferentes Tipos

En Swift, las propiedades son valores asociados que se almacenan en una instancia de clase. O podemos decir que las propiedades son los valores asociados con la estructura, la clase o la enumeración. Hay dos tipos de propiedades: propiedades almacenadas y propiedades calculadas. Las propiedades almacenadas son propiedades que se almacenan en la instancia de la clase. Las propiedades almacenadas almacenan valores constantes y variables. Las propiedades calculadas sirven para crear métodos de obtención y configuración personalizados para las propiedades almacenadas. Las propiedades calculadas son proporcionadas por clases, estructuras y enumeraciones para proporcionar un comportamiento personalizado para las propiedades. Las propiedades almacenadas y calculadas generalmente se asocian con un tipo particular, pero se pueden asociar con cualquier tipo. Estas propiedades se denominan propiedades de tipo. Podemos usar propiedades de tipo para proporcionar valores predeterminados para propiedades de un tipo particular.

Propiedades almacenadas 

Una propiedad almacenada es una propiedad cuyo valor se almacena como parte de la instancia de un tipo particular. Las propiedades almacenadas pueden ser variables o constantes. Podemos usar var para crear una propiedad almacenada variable y let para crear una propiedad almacenada constante.

1. Para propiedades variables almacenadas: aquí usamos var para crear una propiedad variable almacenada. Supongamos que tenemos una estructura llamada Person, que contiene una propiedad almacenada llamada name de tipo String. Así que hemos creado una instancia de Persona y le hemos asignado un valor a la propiedad de nombre. La propiedad de nombre es una propiedad almacenada, por lo que se almacena en la instancia de la estructura Person.

// Swift program for variable stored properties
 
// Creating structure
struct Person
{
 
    // Stored property
    var name: String
}
 
// Creating a Person instance
let person = Person(name: "Geek2Geeks")
 
// Prints "The person's name is Geek2Geeks"
print("The person's name is \(person.name)")

Producción:

The person's name is Geek2Geeks

2. Para propiedades almacenadas constantes: aquí usamos let para crear una propiedad almacenada constante. Supongamos que tenemos otra estructura llamada Empleado, que contiene una propiedad almacenada constante llamada edad de tipo Int. Y también hemos creado una propiedad almacenada constante llamada el nombre de tipo String.

// Swift program for constant stored properties
 
// Structure
struct Employee
{
 
    // Constant stored property
    let age: Int
     
    // Constant stored property
    let name: String
}
 
// Creating an Employee instance
let employee = Employee(age: 30, name: "Geek2Geeks")
 
// Prints "The employee's name is Geek2Geeks"
print("The employee's name is \(employee.name)")
 
// Prints "The employee's age is 30"
print("The employee's age is \(employee.age)")

Producción:

The employee's name is Geek2Geeks
The employee's age is 30

Aquí, hemos creado una instancia de empleado constante y hemos asignado un valor a las propiedades de edad y nombre. La propiedad edad es una propiedad almacenada constante, por lo que se almacena en la instancia de la estructura Empleado. La propiedad de nombre es una propiedad almacenada constante, por lo que se almacena en la instancia de la estructura Empleado.

Propiedades almacenadas perezosas

Las propiedades almacenadas diferidas son una forma de diferir la inicialización de una propiedad hasta que se use por primera vez. Esto es útil para propiedades costosas, como un objeto NSURL, o una colección grande, como un diccionario o array grande. Las propiedades diferidas también son útiles para crear propiedades cuyo valor inicial depende de otra propiedad, como la fecha actual o el nombre de un archivo. Puede crear una propiedad perezosa escribiendo un modificador perezoso antes de su declaración. También es útil cuando el valor inicial de la propiedad requiere una configuración compleja.

Ejemplo:

// Swift program for lazy Property
 
// Class which contain lazy property
class GFG
{
    var Cname : String?
     
    // lazy property
    lazy var course : String = {[weak self] in
         
        guard let x = self else { return "Doesnot warp itself"}
        guard let y = x.Cname else { return "Course not found" }
         
        return "Course is: \(y)"
    }()
     
    init(Cname: String)
    {
        self.Cname = Cname
    }
}
 
// Assigning value
var y = GFG(Cname: "Swift")
 
// Displaying the result
print(y.course)

Producción:

Course is: Swift

Explicación: En el ejemplo anterior hemos creado una clase llamada GFG. Esta clase contiene una propiedad perezosa llamada curso. Esta propiedad devolverá una string que contiene el nombre del curso. En esta propiedad, usamos self débil para eliminar el ciclo de referencia y también usamos guard let para el desenvolvimiento opcional.

Propiedades calculadas 

 Las propiedades calculadas son proporcionadas por clases, estructuras y enumeraciones para proporcionar un comportamiento personalizado para las propiedades. Son similares a los métodos, pero se escriben como parte del tipo en sí y no como parte de una instancia. No almacenan valores, sino que usan getter y setters para recuperar y establecer propiedades y sus valores indirectamente. La propiedad calculada se puede asignar a una propiedad var perezosa y una propiedad calculada que tiene que obtener y establecer no se puede definir como un let constante.

Ejemplo:

// Swift program for Computed Properties
 
// Structure
struct rectangle
{
    var len: Double
    var width: Double
     
    // Computed property
    var perimeter: Double{
     
        // Getter
        get{
            return (2 * (len + width))
        }
         
        // Setter
        set(newperimeter)
        {
            len = (newperimeter - width)/2
        }
    }
}
 
var ob = rectangle(len: 10, width: 5)
 
// Accessing the property
print("Perimeter: ", ob.perimeter)
 
// Setting property with new value
ob.perimeter = 40
 
// Accessing the property
print("Length: ", ob.len)

Producción:

Perimeter:  30.0
Length:  17.5

Explicación: El ejemplo anterior define una estructura llamada rectángulo, que contiene una propiedad llamada perímetro. El perímetro es una propiedad calculada que contiene getter y setter. En esta propiedad encontramos el perímetro del rectángulo y la nueva longitud estableciendo el valor del perímetro.

Propiedades calculadas de solo lectura

La propiedad calculada de solo lectura es una propiedad calculada que está presente solo con getter. No contiene un setter. Esta propiedad siempre devuelve un valor y se puede acceder a ella mediante la sintaxis de puntos. Para declarar una propiedad calculada de solo lectura, simplemente elimine la palabra clave get y sus llaves.

Ejemplo:

// Swift program for read-only computed property
 
// Structure to find the volume of Cuboid
struct CuboidVolume {
   
    var w = 0.0, h = 0.0, d = 0.0
     
    // Reao only computed property
    var Cvolume: Double {
       
        return w * h * d
    }
}
 
// Assigning values
let vol = CuboidVolume(w: 4.0, h: 4.0, d: 4.0)
 
// Accessing read only computed property
print("The volume is \(vol.Cvolume)")

Producción:

The volume is 64.0

Explicación: En este ejemplo, tenemos una clase CuboidVolume que tiene una propiedad llamada Cvolume. Esta propiedad es una propiedad calculada de solo lectura. La propiedad Cvolume es solo un getter y no tiene un setter. La propiedad Cvolume se define como una propiedad calculada de solo lectura porque no necesita almacenar un valor. No es necesario almacenarlo en la instancia de la estructura CuboidVolume, porque solo se usa para calcular el volumen del cuboide.

Observadores de propiedades 

Estos son métodos que el sistema llama automáticamente cuando se establece el valor de una propiedad. Se llama a los observadores de propiedad después de establecer el valor de la propiedad, independientemente de si el nuevo valor es diferente del valor actual de la propiedad. Podemos agregar observadores de propiedades a cualquier propiedad almacenada o calculada y observar los cambios en el valor de esa propiedad. Para una propiedad almacenada, se llama al observador cuando la propiedad se asigna a un nuevo valor. Para una propiedad calculada, se llama al observador cuando se lee o escribe la propiedad. Podemos usar willSet y didSet para observar cambios en el valor de una propiedad.

Ejemplo:

// Swift program for property observers
 
// Class to count the total cat step
class Counter
{
    var totalCatSteps: Int = 0 {
     
        // Property observer
        willSet(newTotalCatSteps)
        {
            print("Setting cat totalSteps: \(newTotalCatSteps)")
        }
         
        // Property observer
        didSet {
            if totalCatSteps > oldValue  {
                print("Added new steps: \(totalCatSteps - oldValue)")
            }
        }
    }
}
 
// Creating class object
let CatStep = Counter()
 
// About to set CatStep to 105
// Added 105 steps
CatStep.totalCatSteps = 105
 
 
// About to set CatStep to 250
// Added 135 steps
CatStep.totalCatSteps = 240
 
// About to set CatStep to 370
// Added 130 steps
CatStep.totalCatSteps = 370

Producción:

Setting cat totalSteps: 105
Added new steps: 105
Setting cat totalSteps: 240
Added new steps: 135
Setting cat totalSteps: 370
Added new steps: 130

Explicación: En el ejemplo anterior, tenemos una clase Counter que contiene los observadores willSet y didSet y se les llama cuando se establece el valor de una propiedad almacenada. Se llama al observador willSet antes de almacenar el valor. Se llama al observador didSet después de almacenar el valor. Aquí, el observador willSet imprime un mensaje antes de almacenar el valor, y el observador didSet imprime un mensaje después de almacenar el valor. El observador didSet imprime un mensaje si el nuevo valor es mayor que el valor anterior de la propiedad.

Envolturas de propiedad 

Un contenedor de propiedad es una propiedad que proporciona una funcionalidad adicional además de otra propiedad. Un contenedor de propiedad es una propiedad que es una subclase de la propiedad que envuelve. La clase contenedora de propiedades es una subclase de la propiedad que envuelve. Agrega funcionalidad adicional a la propiedad que envuelve. O dicho de otro modo, añade una capa de separación entre el código que gestiona cómo se almacena una propiedad y el código que define la propiedad. Para usar un contenedor de propiedades, tenemos que escribir un código de administración cuando definimos un contenedor y luego podemos reutilizar el código de administración aplicándole múltiples propiedades.

Podemos definir un contenedor de propiedades creando una estructura, una enumeración o una clase que defina la propiedad wrapValue. Para aplicar un envoltorio a una propiedad, simplemente escriba el nombre del envoltorio antes del atributo de la propiedad.

Sintaxis :

@propertyWrapper

Envoltura de estructura<T> {

   var valor envuelto: T

   init(valor envuelto: T) {

       self.wrappedValue = valorenvuelto

   }

}

Aquí, Wrapper es un contenedor de propiedad que envuelve un valor de tipo T. La clase Wrapper es una subclase de la propiedad que envuelve. La clase Wrapper anula el comportamiento del contenedor de propiedades, por ejemplo, al anular el definidor del contenedor de propiedades.

Propiedades de tipo

Cada vez que creamos una nueva instancia de una clase, podemos establecer las propiedades de esa instancia. Estas instancias tienen sus propias propiedades y se denominan propiedades de instancia. Entonces, si queremos crear varias instancias de una clase, podemos establecer las propiedades de cada instancia individualmente. Pero no sería una buena práctica establecer las propiedades de cada instancia individualmente. Luego viene el tipo de propiedades al rescate. Las propiedades de tipo se comparten entre todas las instancias de una clase. Solo se crea una copia de las propiedades para todas las instancias de un tipo que creamos.

Las propiedades de tipo se crean utilizando la palabra clave estática. Entonces podemos acceder a las propiedades de un tipo usando el nombre de la clase. Pero no podemos acceder a las propiedades de una instancia usando el nombre de la instancia.

Sintaxis:

    class MyClass { // declaración de clase

       static var typeProperty = «Algún valor» // propiedad de tipo

   }

   MyClass.typeProperty // acceso a la propiedad de tipo

   MyClass.typeProperty = “Algún otro valor” /// asignación de propiedad de tipo

Aquí, hemos creado una propiedad de tipo llamada typeProperty. La clase MyClass tiene una propiedad estática llamada typeProperty. Puede tener cualquier valor. MyClass.typeProperty es una propiedad de tipo. Es una propiedad compartida. Es accesible usando el nombre de la clase.

Ejemplo:

// Swift program for type property
 
// Ios is a type
struct Ios
{
 
    // Version is a type property
    static var version = "iOS 10"
     
    // getVersion is a type method
    static func getVersion()
    {
     
        // Printing the version
        print(version)
    }
}
 
// Printing the version
Ios.getVersion()
 
// Printing the version
print(Ios.version)

Producción:

   iOS 10
   iOS 10

Explicación: Tenemos dos objetos iOs. Uno se crea con la palabra clave struct y el otro se crea con la palabra clave class. Aquí hay un ejemplo simple usando propiedades de tipo. La estructura de Ios tiene una propiedad estática llamada versión. Puede tener cualquier valor. Ios.version es una propiedad de tipo. Es una propiedad compartida. La función estática getVersion() es una función estática. Se llamará usando el nombre de la clase. El cuerpo de esta función se ejecutará una sola vez y se mostrará el valor de la versión. Hemos llamado a la función getVersion() usando el nombre de clase Ios. Esto se debe a que la función getVersion() es una función estática. Se llama usando el nombre de la clase. La función de impresión se utiliza para mostrar el valor de la versión.

Consultar y establecer propiedades de tipo 

La consulta se utiliza para obtener el valor de una propiedad de tipo. La configuración se utiliza para establecer el valor de una propiedad de tipo. Las propiedades de tipo se consultan y establecen utilizando el nombre de la clase. Podemos usar la sintaxis de puntos para consultar y establecer propiedades de tipo.

Ejemplo:

// Swift program to Querying and Setting Type Properties
 
// Ios is a type
struct Ios
{
    static var version = "iOS 10"
     
    // Version is a type property
    static var apilevel: Int{
        return 10
    }
}
 
// Querying
// Printing the version
print(Ios.version)
 
// Setting
// Setting the version
Ios.version = "iOS 11"
 
// Printing the version
print(Ios.version)
 
// Printing the apilevel
print(Ios.apilevel)

Producción:

iOS 10
iOS 11
10

Explicación: Aquí lo que estamos haciendo es crear una estructura llamada Ios. Ios tiene dos tipos de propiedades. Uno se llama versión. Puede tener cualquier valor. El otro se llama apilevel. Puede tener cualquier valor. El apilevel es una propiedad calculada. Se calcula porque depende del valor de la versión. Estamos consultando el valor de la versión utilizando el nombre de clase Ios. La función de impresión se utiliza para mostrar el valor de la versión. De manera similar, estamos configurando el valor de la versión utilizando también el nombre de clase Ios. La función de impresión se utiliza para mostrar el valor de la versión.

Variables globales y locales

En general, las variables son locales a una función. Pero hay algunas excepciones. Las variables globales son variables que se definen fuera de cualquier función. Son accesibles durante todo el programa. Se llaman variables globales. Las variables locales son aquellas variables que se definen dentro de una función. En Swift, también podemos declarar variables calculadas. las variables calculadas calculan su valor sobre la marcha. Eso significa que el valor de la variable se calcula cada vez que se accede a ella. Se llaman variables perezosas.

Ejemplo:

// Swift program to demonstrate the use of global and local variable
 
// Creating global variable
var globalVariable = "This is Global Variable"
 
func geeksforgeeks()
{
 
    // Creating local variable
    var localVariable = "This is Local Variable"
 
    print("Global Variable: \(globalVariable)")
    print("Local Variable: \(localVariable)")
}
 
// Calling the geeksforgeeks function
geeksforgeeks()
 
// Printing the global variable
print(globalVariable)

Producción:

Global Variable: This is Global Variable
Local Variable: This is Local Variable
This is Global Variable

Explicación: Aquí, hemos creado una variable global llamada globalVariable. La variable global es una variable global. Es accesible durante todo el programa. La variable local se llama variable local. La variable local es una variable local. Solo es accesible dentro de la función geeksforgeeks.