Swift Language
Zmienne i właściwości

Uwagi

Tworzenie zmiennej

Zadeklaruj nową zmienną za pomocą var , a następnie nazwę, typ i wartość:

var num: Int = 10

Zmienne mogą mieć zmienione wartości:

num = 20 // num now equals 20

Chyba że są zdefiniowane przez let :

let num: Int = 10 // num cannot change

Swift określa typ zmiennej, więc nie zawsze musisz deklarować typ zmiennej:

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

Nazwy zmiennych nie są ograniczone do liter i cyfr - mogą również zawierać większość innych znaków Unicode, chociaż istnieją pewne ograniczenia

Nazwy stałych i zmiennych nie mogą zawierać znaków białych znaków, symboli matematycznych, strzałek, punktów kodu Unicode prywatnego użytku (lub nieprawidłowych) ani znaków rysujących linie i ramki. Nie mogą też zaczynać się od cyfry

_{Źródło developer.apple.com}

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

Podstawy nieruchomości

Właściwości mogą być dodawane do klasy lub struktury (również technicznie wylicza , patrz przykład „Obliczone właściwości”). Dodają wartości, które są powiązane z instancjami klas / struktur:

class Dog {
    var name = ""
}

W powyższym przypadku instancje Dog mają właściwość o nazwie name typu String . Dostęp do właściwości i modyfikacja można uzyskać w instancjach Dog :

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

Tego rodzaju właściwości są uważane za przechowywane , ponieważ przechowują coś w obiekcie i wpływają na jego pamięć.

Leniwe przechowywane właściwości

Leniwe przechowywane właściwości mają wartości, które nie są obliczane do pierwszego dostępu. Jest to przydatne do oszczędzania pamięci, gdy obliczenia zmiennej są drogie obliczeniowo. Zadeklarujesz leniwą właściwość za pomocą lazy :

lazy var veryExpensiveVariable = expensiveMethod()

Często przypisywany jest do wartości zwracanej zamknięcia:

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

Leniwe przechowywane właściwości należy zadeklarować za pomocą var .

Obliczone właściwości

W odróżnieniu od przechowywanych właściwości, obliczone właściwości są budowane za pomocą modułu pobierającego i ustawiającego, wykonując niezbędny kod podczas uzyskiwania dostępu i ustawiania. Obliczone właściwości muszą definiować 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..."

Właściwość obliczona tylko do odczytu jest nadal deklarowana za pomocą var :

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

Właściwości obliczone tylko do odczytu można skrócić, aby wykluczyć get :

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

Zmienne lokalne i globalne

Zmienne lokalne są zdefiniowane w ramach funkcji, metody lub zamknięcia:

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

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

Zmienne globalne są zdefiniowane poza funkcją, metodą lub zamknięciem i nie są zdefiniowane w ramach typu (należy myśleć poza wszystkimi nawiasami). Można ich używać wszędzie:

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

Zmienne globalne są definiowane leniwie (patrz przykład „Leniwe właściwości”).

Wpisz właściwości

Właściwości typu są właściwościami samego typu, a nie instancji. Mogą to być zarówno właściwości zapisane, jak i obliczone. Deklarujesz właściwość type ze static :

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

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

W klasie można użyć słowa kluczowego class zamiast static aby można było go zastąpić. Można to jednak zastosować tylko do obliczonych właściwości:

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

Jest to często używane w przypadku wzoru singleton .

Obserwatorzy nieruchomości

Obserwatorzy właściwości reagują na zmiany wartości właściwości.

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 jest wywoływana przed myProperty jest ustawiony. Nowa wartość jest dostępna jako newValue , a stara wartość jest nadal dostępna jako myProperty .
• didSet nazywa po myProperty jest ustawiony. Stara wartość jest dostępna jako oldValue , a nowa wartość jest teraz dostępna jako myProperty .

Uwaga: didSet i willSet nie będą wywoływane w następujących przypadkach:

• Przypisywanie wartości początkowej
• Modyfikowanie zmiennej w ramach własnego didSet lub willSet

• Nazwy parametrów dla oldValue i newValue didSet i willSet można również zadeklarować w celu zwiększenia czytelności:

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

Przestroga: Chociaż można zadeklarować nazwy parametrów ustawiających, należy zachować ostrożność, aby nie mieszać nazw:

• willSet(oldValue) i didSet(newValue) są całkowicie legalne, ale znacznie dezorientują czytelników twojego kodu.