Swift Language
Variabelen & eigenschappen

Opmerkingen

Een variabele maken

Declareer een nieuwe variabele met var , gevolgd door een naam, type en waarde:

var num: Int = 10

Variabelen kunnen hun waarden laten wijzigen:

num = 20 // num now equals 20

Tenzij ze zijn gedefinieerd met let :

let num: Int = 10 // num cannot change

Swift leidt het type variabele af, zodat u niet altijd het variabele type hoeft aan te geven:

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

Variabelenamen zijn niet beperkt tot letters en cijfers - ze kunnen ook de meeste andere unicode-tekens bevatten, hoewel er enkele beperkingen zijn

Namen van constante en variabelen mogen geen witruimte-tekens, wiskundige symbolen, pijlen, privégebruik (of ongeldige) Unicode-codepunten of lijn- en vaktekens bevatten. Ze kunnen ook niet met een nummer beginnen

_{Bron developer.apple.com}

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

Basics van onroerend goed

Eigenschappen kunnen worden toegevoegd aan een klasse of struct (technisch gezien ook, zie het voorbeeld "Berekende eigenschappen"). Deze voegen waarden toe die verband houden met instanties van klassen / structs:

class Dog {
    var name = ""
}

In het bovenstaande geval hebben instanties van Dog een eigenschap met de naam name van het type String . De eigenschap kan worden geopend en gewijzigd op exemplaren van Dog :

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

Dit soort eigenschappen worden als opgeslagen eigenschappen beschouwd, omdat ze iets op een object opslaan en het geheugen beïnvloeden.

Luie opgeslagen eigenschappen

Lazy opgeslagen eigenschappen hebben waarden die niet worden berekend tot ze voor het eerst worden gebruikt. Dit is handig voor geheugenbesparing wanneer de berekening van de variabele rekenkundig duur is. Je verklaart een lui eigendom met lazy :

lazy var veryExpensiveVariable = expensiveMethod()

Vaak wordt het toegewezen aan een retourwaarde van een sluiting:

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

Luie opgeslagen eigenschappen moeten worden aangegeven met var .

Berekende eigenschappen

In tegenstelling tot opgeslagen eigenschappen, worden berekende eigenschappen gebouwd met een getter en een setter, die de nodige code uitvoeren wanneer ze worden geopend en ingesteld. Berekende eigenschappen moeten een type definiëren:

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

Een alleen-lezen berekende eigenschap wordt nog steeds gedeclareerd met een var :

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

Alleen-lezen berekende eigenschappen kunnen worden ingekort om get te sluiten:

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

Lokale en globale variabelen

Lokale variabelen worden gedefinieerd binnen een functie, methode of afsluiting:

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

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

Globale variabelen worden gedefinieerd buiten een functie, methode of sluiting en worden niet gedefinieerd binnen een type (denk buiten alle haakjes). Ze kunnen overal worden gebruikt:

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 variabelen worden lui gedefinieerd (zie het voorbeeld "Luie eigenschappen").

Type eigenschappen

Type-eigenschappen zijn eigenschappen op het type zelf, niet op het exemplaar. Ze kunnen zowel opgeslagen als berekende eigenschappen zijn. U declareert een eigenschap type met static :

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

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

In een klasse kunt u het trefwoord class plaats van static om het te overschrijven. U kunt dit echter alleen toepassen op berekende eigenschappen:

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

Dit wordt vaak gebruikt met het singleton-patroon .

Waarnemers van onroerend goed

Eigenschapwaarnemers reageren op wijzigingen in de waarde van een eigenschap.

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 wordt aangeroepen voordat myProperty is ingesteld. De nieuwe waarde is beschikbaar als newValue en de oude waarde is nog steeds beschikbaar als myProperty .
• didSet wordt aangeroepen nadat myProperty is ingesteld. De oude waarde is beschikbaar als oldValue en de nieuwe waarde is nu beschikbaar als myProperty .

Opmerking: didSet en willSet worden niet aangeroepen in de volgende gevallen:

• Een beginwaarde toewijzen
• De variabele binnen zijn eigen didSet of willSet

• De parameternamen voor oldValue en newValue van didSet en willSet kunnen ook worden verklaard om de leesbaarheid te vergroten:

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

Let op: Hoewel het wordt ondersteund om de parameternamen van de setter te declareren, moet u voorzichtig zijn om de namen niet te verwarren:

• willSet(oldValue) en didSet(newValue) zijn volledig legaal, maar zullen de lezers van uw code aanzienlijk verwarren.