Swift Language
Variabler och egenskaper

Anmärkningar

Skapa en variabel

Förklara en ny variabel med var , följt av ett namn, typ och värde:

var num: Int = 10

Variabler kan ändra sina värden:

num = 20 // num now equals 20

Om de inte definieras med let :

let num: Int = 10 // num cannot change

Snabbt anger variabeltypen, så du behöver inte alltid ange variabeltyp:

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

Variabla namn är inte begränsade till bokstäver och siffror - de kan också innehålla de flesta andra unicode-tecken, även om det finns vissa begränsningar

Konstanta och variabla namn kan inte innehålla blankstegstecken, matematiska symboler, pilar, privatanvändning (eller ogiltig) Unicode-kodpunkter eller rad- och ruta-tecken. De kan inte heller börja med ett nummer

_{Källa Developer.apple.com}

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

Fastighetsgrunder

Egenskaper kan läggas till i en klass eller struktur (tekniskt också enums , se exempel på "Beräknade egenskaper"). Dessa lägger till värden som associeras med instanser av klasser / strukturer:

class Dog {
    var name = ""
}

I ovanstående fall har fall av Dog en egenskap som heter name av typen String . Fastigheten kan nås och ändras i fall av Dog :

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

Dessa typer av egenskaper anses lagrade egenskaper , eftersom de lagrar något på ett objekt och påverkar dess minne.

Lat lagrade egenskaper

Lazy lagrade egenskaper har värden som inte beräknas förrän du har åtkomst till det. Detta är användbart för minnesbesparing när variabelns beräkning är beräkningsbar. Du förklarar en lat egendom med lazy :

lazy var veryExpensiveVariable = expensiveMethod()

Ofta tilldelas det ett returvärde för en stängning:

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

Lat lagrade egenskaper måste deklareras med var .

Beräknade egenskaper

Till skillnad från lagrade egenskaper är beräknade egenskaper byggda med en getter och en setter, och utför nödvändig kod när du kommer åt och ställer in. Beräknade egenskaper måste definiera en typ:

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

En skrivskyddad egenskap förklaras fortfarande med en var :

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

Beräkningsegenskaper för skrivskydd kan förkortas för att utesluta get :

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

Lokala och globala variabler

Lokala variabler definieras inom en funktion, metod eller stängning:

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

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

Globala variabler definieras utanför en funktion, metod eller stängning och definieras inte inom en typ (tänk utanför alla parenteser). De kan användas var som helst:

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

Globala variabler definieras lata (se exempel "Lazy Properties").

Skriv egenskaper

Typegenskaper är egenskaper för själva typen, inte på instansen. De kan vara både lagrade eller beräknade egenskaper. Du förklarar en typegenskap med static :

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

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

I en klass, kan du använda class nyckelordet istället för static för att göra det overridable. Du kan emellertid endast tillämpa detta på beräknade egenskaper:

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

Detta används ofta med singletonmönstret .

Fastighetsobservatörer

Fastighetsobservatörer svarar på förändringar i fastighetens värde.

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 kallas innan myProperty är inställt. Det nya värdet är tillgängligt som newValue , och det gamla värdet är fortfarande tillgängligt som myProperty .
• didSet kallas efter att myProperty har ställts in. Det gamla värdet är tillgängligt som oldValue , och det nya värdet är nu tillgängligt som myProperty .

Obs: didSet och willSet kommer inte att anropas i följande fall:

• Tilldela ett initialvärde
• Ändra variabeln inom sin egen didSet eller willSet

• Parameternamnen för oldValue och newValue of didSet och willSet kan också förklaras öka läsbarheten:

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

Varning: Även om det stöds att förklara namn för parameterparametern, bör man vara försiktig så att man inte blandar upp namn:

• willSet(oldValue) och didSet(newValue) är helt lagliga, men kommer att förvirra läsarna till din kod avsevärt.