Swift Language
Variabili e proprietà

Osservazioni

Creare una variabile

Dichiarare una nuova variabile con var , seguita da un nome, tipo e valore:

var num: Int = 10

Le variabili possono avere i loro valori modificati:

num = 20 // num now equals 20

A meno che non siano definiti con let :

let num: Int = 10 // num cannot change

Swift deduce il tipo di variabile, quindi non devi sempre dichiarare il tipo di variabile:

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

I nomi delle variabili non sono limitati a lettere e numeri, ma possono anche contenere la maggior parte degli altri caratteri Unicode, sebbene vi siano alcune restrizioni

I nomi di costanti e variabili non possono contenere caratteri di spazi bianchi, simboli matematici, frecce, punti di codice Unicode di uso privato (o non validi) o caratteri di disegno di linee e riquadri. Né possono iniziare con un numero

_{Fonte developer.apple.com}

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

Nozioni di base sulla proprietà

Le proprietà possono essere aggiunte a una classe o una struttura (anche tecnicamente enum , vedi esempio "Proprietà calcolate"). Questi aggiungono valori che si associano alle istanze di classi / structs:

class Dog {
    var name = ""
}

Nel caso precedente, le istanze di Dog hanno una proprietà denominata name di tipo String . La proprietà è accessibile e modificata in caso di Dog :

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

Questi tipi di proprietà sono considerati proprietà memorizzate , poiché memorizzano qualcosa su un oggetto e ne influenzano la memoria.

Proprietà memorizzate pigre

Le proprietà memorizzate pigro hanno valori che non vengono calcolati fino al primo accesso. Ciò è utile per il salvataggio della memoria quando il calcolo della variabile è dispendioso dal punto di vista computazionale. Dichiari una proprietà lazy con lazy :

lazy var veryExpensiveVariable = expensiveMethod()

Spesso è assegnato a un valore di ritorno di una chiusura:

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

Le proprietà memorizzate pigro devono essere dichiarate con var .

Proprietà calcolate

Diversamente dalle proprietà memorizzate, le proprietà calcolate vengono create con un getter e un setter, eseguendo il codice necessario quando si accede e si imposta. Le proprietà calcolate devono definire 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 proprietà calcolata di sola lettura è ancora dichiarata con una var :

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

Le proprietà calcolate di sola lettura possono essere abbreviate per escludere get :

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

Variabili locali e globali

Le variabili locali sono definite all'interno di una funzione, metodo o chiusura:

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

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

Le variabili globali sono definite al di fuori di una funzione, metodo o chiusura e non sono definite all'interno di un tipo (si pensi al di fuori di tutte le parentesi). Possono essere utilizzati ovunque:

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!
    }
}

Le variabili globali sono definite pigramente (vedi esempio "Proprietà Lazy").

Tipo Proprietà

Le proprietà del tipo sono proprietà sul tipo stesso, non sull'istanza. Possono essere sia proprietà memorizzate che calcolate. Si dichiara una proprietà di tipo con static :

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

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

In una classe, è possibile utilizzare la parola chiave della class anziché static per renderla sovrascrivibile. Tuttavia, puoi applicarlo solo su proprietà calcolate:

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

Questo è usato spesso con il modello singleton .

Osservatori di proprietà

Gli osservatori di proprietà rispondono alle modifiche al valore di una proprietà.

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 viene chiamato prima che myProperty sia impostato. Il nuovo valore è disponibile come newValue e il vecchio valore è ancora disponibile come myProperty .
• didSet viene chiamato dopo che myProperty è impostato. Il vecchio valore è disponibile come oldValue e il nuovo valore è ora disponibile come myProperty .

Nota: didSet e willSet non verranno richiamati nei seguenti casi:

• Assegnare un valore iniziale
• Modifica della variabile all'interno del proprio didSet o willSet

• I nomi dei parametri per oldValue e newValue di didSet e willSet possono anche essere dichiarati per aumentare la leggibilità:

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

Attenzione: mentre è supportato per dichiarare i nomi dei parametri setter, si dovrebbe essere prudenti a non mescolare i nomi:

• willSet(oldValue) e didSet(newValue) sono completamente legali, ma confonderanno considerevolmente i lettori del tuo codice.