Swift Language
Variablen & Eigenschaften

Bemerkungen

Eine Variable erstellen

Deklarieren Sie eine neue Variable mit var , gefolgt von Name, Typ und Wert:

var num: Int = 10

Bei Variablen kann der Wert geändert werden:

num = 20 // num now equals 20

Sofern sie nicht mit let definiert sind:

let num: Int = 10 // num cannot change

Swift bezieht sich auf den Variablentyp, sodass Sie nicht immer den Variablentyp deklarieren müssen:

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

Variablennamen sind nicht auf Buchstaben und Zahlen beschränkt - sie können auch die meisten anderen Unicode-Zeichen enthalten, es gibt jedoch einige Einschränkungen

Konstanten- und Variablennamen dürfen keine Leerzeichen, mathematische Symbole, Pfeile, (oder ungültige) Unicode-Codepunkte für den privaten Gebrauch oder Linien- und Boxzeichen enthalten. Sie können auch nicht mit einer Zahl beginnen

_{Quelle developer.apple.com}

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

Eigenschaften des Eigentums

Eigenschaften können einer Klasse oder Struktur hinzugefügt werden (auch technische Aufzählungen , siehe Beispiel "Berechnete Eigenschaften"). Diese fügen Werte hinzu, die Instanzen von Klassen / Strukturen zugeordnet sind:

class Dog {
    var name = ""
}

In dem obigen Fall haben Instanzen von Dog eine Eigenschaft mit dem Namen name vom Typ String . Die Eigenschaft kann in Instanzen von Dog aufgerufen und geändert werden:

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

Diese Eigenschaften gelten als gespeicherte Eigenschaften , da sie etwas in einem Objekt speichern und sich auf dessen Speicher auswirken.

Faule gespeicherte Eigenschaften

Lazy gespeicherte Eigenschaften haben Werte, die erst beim ersten Zugriff berechnet werden. Dies ist zum Speichern des Speichers hilfreich, wenn die Berechnung der Variablen rechnerisch teuer ist. Sie erklären eine faule Eigenschaft mit lazy :

lazy var veryExpensiveVariable = expensiveMethod()

Oft wird es einem Rückgabewert eines Abschlusses zugewiesen:

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

Faul gespeicherte Eigenschaften müssen mit var deklariert werden.

Berechnete Eigenschaften

Im Unterschied zu den gespeicherten Eigenschaften werden berechnete Eigenschaften mit einem Getter und einem Setter erstellt, die den erforderlichen Code ausführen, wenn auf sie zugegriffen wird, und sie festlegen. Berechnete Eigenschaften müssen einen Typ definieren:

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

Eine schreibgeschützte berechnete Eigenschaft wird weiterhin mit einem var deklariert:

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

Schreibgeschützte berechnete Eigenschaften können verkürzt werden, um Folgendes zu get :

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

Lokale und globale Variablen

Lokale Variablen werden in einer Funktion, Methode oder Schließung definiert:

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

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

Globale Variablen werden außerhalb einer Funktion, einer Methode oder eines Abschlusses definiert und nicht innerhalb eines Typs definiert (denken Sie außerhalb der Klammern). Sie können überall verwendet werden:

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

Globale Variablen werden träge definiert (siehe Beispiel "Lazy Properties").

Geben Sie Eigenschaften ein

Typeneigenschaften sind Eigenschaften des Typs selbst, nicht der Instanz. Sie können sowohl gespeicherte als auch berechnete Eigenschaften sein. Sie deklarieren eine Typ-Eigenschaft mit static :

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

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

In einer Klasse können Sie das Schlüsselwort class anstelle von static , um es überschreibbar zu machen. Sie können dies jedoch nur auf berechnete Eigenschaften anwenden:

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

Dies wird häufig beim Singleton-Pattern verwendet .

Immobilienbeobachter

Immobilienbeobachter reagieren auf Änderungen am Wert einer Eigenschaft.

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 wird aufgerufen, bevor myProperty gesetzt ist. Der neue Wert ist als newValue verfügbar, und der alte Wert ist noch als myProperty verfügbar.
• didSet wird aufgerufen, nachdem myProperty gesetzt ist. Der alte Wert ist als oldValue verfügbar, und der neue Wert ist jetzt als myProperty verfügbar.

Hinweis: didSet und willSet werden in den folgenden Fällen nicht aufgerufen:

• Einen Anfangswert zuweisen
• Ändern der Variable innerhalb ihres eigenen didSet oder willSet

• Die Parameternamen für oldValue und newValue von didSet und willSet können ebenfalls deklariert werden, um die Lesbarkeit zu erhöhen:

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

Achtung: Es wird zwar unterstützt, die Namen der Setterparameter zu deklarieren, man sollte jedoch vorsichtig sein, die Namen nicht zu vermischen:

• willSet(oldValue) und didSet(newValue) sind völlig legal, können jedoch die Leser Ihres Codes erheblich verwirren.