Swift Language
Variables y propiedades

Observaciones

Creando una Variable

Declare una nueva variable con var , seguido de un nombre, tipo y valor:

var num: Int = 10

Las variables pueden tener sus valores cambiados:

num = 20 // num now equals 20

A menos que se definan con let :

let num: Int = 10 // num cannot change

Swift infiere el tipo de variable, por lo que no siempre tiene que declarar el tipo de variable:

let ten = 10 // num is an Int
let pi = 3.14 // pi is a Double
let floatPi: Float = 3.14 // floatPi is a Float

Los nombres de variables no están restringidos a letras y números, también pueden contener la mayoría de los otros caracteres Unicode, aunque hay algunas restricciones

Los nombres de constante y variable no pueden contener caracteres de espacio en blanco, símbolos matemáticos, flechas, puntos de código Unicode de uso privado (o no válido) o caracteres de dibujo de líneas y cuadros. Tampoco pueden comenzar con un número.

_{Fuente developer.apple.com}

var π: Double = 3.14159
var 🍎🍏: String = "Apples"

Conceptos básicos de propiedad

Las propiedades se pueden agregar a una clase o estructura (técnicamente también enumerados , vea el ejemplo "Propiedades calculadas "). Estos agregan valores que se asocian con instancias de clases / estructuras:

class Dog {
    var name = ""
}

En el caso anterior, las instancias de Dog tienen una propiedad llamada name de tipo String . Se puede acceder y modificar la propiedad en instancias de Dog :

let myDog = Dog()
myDog.name = "Doggy" // myDog's name is now "Doggy"

Estos tipos de propiedades se consideran propiedades almacenadas , ya que almacenan algo en un objeto y afectan su memoria.

Propiedades almacenadas perezosas

Las propiedades almacenadas perezosas tienen valores que no se calculan hasta que se accede por primera vez. Esto es útil para guardar memoria cuando el cálculo de la variable es computacionalmente costoso. Usted declara una propiedad lazy con lazy :

lazy var veryExpensiveVariable = expensiveMethod()

A menudo se asigna a un valor de retorno de un cierre:

lazy var veryExpensiveString = { () -> String in
    var str = expensiveStrFetch()
    str.expensiveManipulation(integer: arc4random_uniform(5))
    return str
}()

Las propiedades almacenadas perezosas deben ser declaradas con var .

Propiedades calculadas

A diferencia de las propiedades almacenadas, las propiedades computadas se construyen con un getter y un setter, realizando el código necesario cuando se accede y se establece. Las propiedades calculadas deben definir un tipo:

var pi = 3.14

class Circle {
    var radius = 0.0
    var circumference: Double {
        get {
            return pi * radius * 2
        }
        set {
            radius = newValue / pi / 2
        }
    }
}

let circle = Circle()
circle.radius = 1
print(circle.circumference) // Prints "6.28"
circle.circumference = 14
print(circle.radius) // Prints "2.229..."

Una propiedad calculada de solo lectura todavía se declara con una var :

var circumference: Double {
    get {
        return pi * radius * 2
    }
}

Las propiedades calculadas de solo lectura se pueden acortar para excluir get :

var circumference: Double {
    return pi * radius * 2
}

Variables locales y globales

Las variables locales se definen dentro de una función, método o cierre:

func printSomething() {
    let localString = "I'm local!"
    print(localString)
}

func printSomethingAgain() {
    print(localString) // error
}

Las variables globales se definen fuera de una función, método o cierre, y no se definen dentro de un tipo (piense fuera de todos los corchetes). Se pueden utilizar en cualquier lugar:

let globalString = "I'm global!"
print(globalString)

func useGlobalString() {
    print(globalString) // works!
}

for i in 0..<2 {
    print(globalString) // works!
}

class GlobalStringUser {
    var computeGlobalString {
        return globalString // works!
    }
}

Las variables globales se definen perezosamente (vea el ejemplo de "Propiedades perezosas").

Tipo de propiedades

Las propiedades de tipo son propiedades en el tipo en sí, no en la instancia. Pueden ser tanto propiedades almacenadas como computadas. Usted declara una propiedad de tipo con static :

struct Dog {
    static var noise = "Bark!"
}

print(Dog.noise) // Prints "Bark!"

En una clase, puede usar la palabra clave de class lugar de static para hacerla reemplazable. Sin embargo, solo puede aplicar esto en las propiedades computadas:

class Animal {
    class var noise: String {
        return "Animal noise!"
    }
}
class Pig: Animal {
    override class var noise: String {
        return "Oink oink!"
    }
}

Esto se utiliza a menudo con el patrón de singleton .

Observadores de la propiedad

Los observadores de propiedades responden a cambios en el valor de una propiedad.

var myProperty = 5 {
    willSet {
        print("Will set to \(newValue). It was previously \(myProperty)")
    }
    didSet {
        print("Did set to \(myProperty). It was previously \(oldValue)")
    }
}
myProperty = 6
// prints: Will set to 6, It was previously 5
// prints: Did set to 6. It was previously 5

• willSet se llama antes de myProperty se establece. El nuevo valor está disponible como newValue , y el valor anterior todavía está disponible como myProperty .
• didSet se llama después de establecer myProperty . El valor de edad está disponible como oldValue , y el nuevo valor ya está disponible como myProperty .

Nota: didSet y willSet no se willSet en los siguientes casos:

• Asignando un valor inicial
• Modificando la variable dentro de su propio didSet o willSet

• Los nombres de parámetros para oldValue y newValue de didSet y willSet también se pueden declarar para aumentar la legibilidad:

var myFontSize = 10 {
    willSet(newFontSize) {
        print("Will set font to \(newFontSize), it was \(myFontSize)")
    }
    didSet(oldFontSize) {
        print("Did set font to \(myFontSize), it was \(oldFontSize)")
    }
}

Precaución: si bien se admite la declaración de nombres de parámetros de establecimiento, se debe tener cuidado de no mezclar los nombres:

• willSet(oldValue) y didSet(newValue) son completamente legales, pero confundirán considerablemente a los lectores de su código.