Swift Language
Переменные и свойства

замечания

Создание переменной

Объявите новую переменную с var , за которой следует имя, тип и значение:

var num: Int = 10

Переменные могут иметь свои значения:

num = 20 // num now equals 20

Если они не определены с let :

let num: Int = 10 // num cannot change

Swift указывает тип переменной, поэтому вам не всегда нужно объявлять тип переменной:

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

Имена переменных не ограничены буквами и цифрами - они могут также содержать большинство других символов в Юникоде, хотя существуют некоторые ограничения

Имена констант и переменных не могут содержать пробельные символы, математические символы, стрелки, частные (или недействительные) кодовые точки Юникода или символы рисунка строки и окна. Они также не могут начинаться с числа

_{Источник developer.apple.com}

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

Основы собственности

Свойства могут быть добавлены к классу или структуре (технически перечислены также, см. Пример «Вычислимые свойства»). Они добавляют значения, которые ассоциируются с экземплярами классов / структур:

class Dog {
    var name = ""
}

В приведенном выше случае экземпляры Dog имеют свойство с именем name type String . Свойство может быть доступно и изменено на экземплярах Dog :

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

Эти типы свойств считаются хранимыми свойствами , поскольку они хранят что-то на объекте и влияют на его память.

Леновые сохраненные свойства

Lazy хранимые свойства имеют значения, которые не вычисляются до первого доступа. Это полезно для экономии памяти, когда вычисление переменной вычисляется дорого. Вы объявляете ленивое имущество lazy :

lazy var veryExpensiveVariable = expensiveMethod()

Часто ему присваивается возвращаемое значение замыкания:

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

Ленивые хранимые свойства должны быть объявлены с помощью var .

Вычислимые свойства

В отличие от хранимых свойств, вычисляемые свойства создаются с помощью геттера и сеттера, выполняя необходимый код при доступе и настройке. Вычисленные свойства должны определять тип:

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

Вычислимое свойство только для чтения все еще объявляется с помощью var :

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

Выделенные свойства только для чтения можно сократить, чтобы исключить get :

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

Локальные и глобальные переменные

Локальные переменные определяются внутри функции, метода или закрытия:

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

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

Глобальные переменные определяются вне функции, метода или закрытия и не определены внутри типа (думайте вне всех скобок). Они могут использоваться везде:

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

Глобальные переменные определяются лениво (см. Пример «Lazy Properties»).

Свойства типа

Свойства типа - это свойства самого типа, а не экземпляра. Они могут быть как сохраненными, так и вычисленными свойствами. Вы объявляете свойство type со static :

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

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

В классе вы можете использовать ключевое слово class вместо static чтобы сделать его переопределяемым. Однако вы можете применить это только к вычисленным свойствам:

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

Это часто используется с шаблоном singleton .

Наблюдатели за недвижимостью

Наблюдатели собственности реагируют на изменения стоимости объекта.

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 вызывается до myProperty будет установлен myProperty . Новое значение доступно как newValue , и старое значение по-прежнему доступно как myProperty .
• didSet вызывается после установки myProperty . Старое значение доступно как oldValue , и новое значение теперь доступно как myProperty .

Примечание: didSet и willSet не будут вызываться в следующих случаях:

• Присвоение начального значения
• Изменение переменной в ее собственном didSet или willSet

• Имена параметров для oldValue и newValue of didSet и willSet также могут быть объявлены для повышения удобочитаемости:

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

Внимание. Хотя при объявлении имен параметров сеттера необходимо соблюдать осторожность, чтобы не смешивать имена:

• willSet(oldValue) и didSet(newValue) полностью легальны, но значительно запутают читателей вашего кода.