Swift - Свойства

Язык Swift 4 предоставляет свойства класса, перечисления или структуры для связывания значений. Свойства можно разделить на сохраненные свойства и вычисляемые свойства.

Разница между сохраненными свойствами и вычисленными свойствами

Сохраненная собственность Вычисленное свойство
Сохранять значения констант и переменных как экземпляр Вычисляйте значение, а не сохраняйте его
Предоставляется классами и структурами Предоставляется классами, перечислениями и структурами

И сохраненные, и вычисляемые свойства связаны с типом экземпляров. Когда свойства связаны со значениями его типа, он определяется как «Свойства типа». Сохраненные и вычисляемые свойства обычно связаны с экземплярами определенного типа. Однако свойства также могут быть связаны с самим типом. Такие свойства известны как свойства типа. Также используются наблюдатели за недвижимостью.

  • Для наблюдения за значением сохраненных свойств
  • Чтобы наблюдать свойство унаследованного подкласса, производного от суперкласса

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

Swift 4 представляет концепцию хранимых свойств для хранения экземпляров констант и переменных. Сохраненные свойства констант определяются ключевым словом let, а сохраненные свойства переменных определяются ключевым словом var.

  • Во время определения свойство Stored предоставляет значение по умолчанию.
  • Во время инициализации пользователь может инициализировать и изменять начальные значения.
struct Number {
   var digits: Int
   let pi = 3.1415
}

var n = Number(digits: 12345)
n.digits = 67

print("\(n.digits)")
print("\(n.pi)")

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

67
3.1415

Рассмотрим следующую строку в приведенном выше коде -

let pi = 3.1415

Здесь переменная pi инициализируется как сохраненное значение свойства с экземпляром pi = 3,1415. Таким образом, при каждой ссылке на экземпляр он будет содержать только значение 3,1415.

Другой способ сохранить свойство - иметь постоянные структуры. Таким образом, весь экземпляр структур будет рассматриваться как «Сохраненные свойства констант».

struct Number {
   var digits: Int
   let numbers = 3.1415
}

var n = Number(digits: 12345)
n.digits = 67

print("\(n.digits)")
print("\(n.numbers)")
n.numbers = 8.7

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

error: cannot assign to 'numbers' in 'n'
n.numbers = 8.7

Вместо повторной инициализации «числа» на 8.7 он вернет сообщение об ошибке, указывающее, что «число» объявлено как постоянное.

Ленивая сохраненная собственность

Swift 4 предоставляет гибкое свойство под названием «Lazy Stored Property», в котором оно не будет вычислять начальные значения при первой инициализации переменной. Модификатор lazy используется перед объявлением переменной, чтобы сделать ее ленивым сохраненным свойством.

Ленивые свойства используются -

  • Чтобы отложить создание объекта.
  • Когда свойство зависит от других частей класса, которые еще не известны
class sample {
   lazy var no = number()    // `var` declaration is required.
}

class number {
   var name = "Swift 4"
}

var firstsample = sample()
print(firstsample.no.name)

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

Swift 4

Переменные экземпляра

В Objective C хранимые свойства также имеют переменные экземпляра для целей резервного копирования для хранения значений, объявленных в сохраненном свойстве.

Swift 4 объединяет обе эти концепции в одно объявление «хранимого свойства». Вместо наличия соответствующей переменной экземпляра и резервного значения «сохраненное свойство» содержит всю интегрированную информацию, определенную в одном месте о свойстве переменных по имени переменной, типу данных и функциям управления памятью.

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

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

class sample {
   var no1 = 0.0, no2 = 0.0
   var length = 300.0, breadth = 150.0

   var middle: (Double, Double) {
      get {
         return (length / 2, breadth / 2)
      }
      
      set(axis){
         no1 = axis.0 - (length / 2)
         no2 = axis.1 - (breadth / 2)
      }
   }
}

var result = sample()
print(result.middle)
result.middle = (0.0, 10.0)

print(result.no1)
print(result.no2)

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

(150.0, 75.0)
-150.0
-65.0

Когда вычисляемое свойство оставило новое значение неопределенным, для этой конкретной переменной будет установлено значение по умолчанию.

Вычисляемые свойства как свойства только для чтения

Свойство только для чтения в вычисляемом свойстве определяется как свойство с геттером, но без сеттера. Он всегда используется для возврата значения. Далее доступ к переменным осуществляется через '.' Синтаксис, но нельзя установить другое значение.

class film {
   var head = ""
   var duration = 0.0
   var metaInfo: [String:String] {
      return [
         "head": self.head,
         "duration":"\(self.duration)"
      ]
   }
}

var movie = film()
movie.head = "Swift 4 Properties"
movie.duration = 3.09

print(movie.metaInfo["head"]!)
print(movie.metaInfo["duration"]!)

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

Swift 4 Properties
3.09

Вычисляемые свойства как наблюдатели за свойствами

В Swift 4 для наблюдения и реагирования на значения свойств используются Property Observers. Каждый раз, когда устанавливаются значения свойств, вызываются наблюдатели свойств. За исключением ленивых сохраненных свойств, мы можем добавить наблюдателей за свойством к «унаследованному» свойству методом «переопределения».

Наблюдатели за свойствами могут быть определены либо

  • Перед сохранением значения - willset

  • После сохранения нового значения - didset

  • Когда свойство установлено в инициализаторе willset и didset наблюдатели не могут быть вызваны.

class Samplepgm {
   var counter: Int = 0 {
      willSet(newTotal){
         print("Total Counter is: \(newTotal)")
      }
      
      didSet {
         if counter > oldValue {
            print("Newly Added Counter \(counter - oldValue)")
         }
      }
   }
}

let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

Total Counter is: 100
Newly Added Counter 100
Total Counter is: 800
Newly Added Counter 700

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

Локальная и глобальная переменные объявляются для вычисления и наблюдения за свойствами.

Локальные переменные Глобальные переменные
Переменные, которые определены в контексте функции, метода или замыкания. Переменные, которые определены вне функции, метода, замыкания или контекста типа.
Используется для хранения и получения значений. Используется для хранения и получения значений.
Сохраненные свойства используются для получения и установки значений. Сохраненные свойства используются для получения и установки значений.
Также используются вычисленные свойства. Также используются вычисленные свойства.

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

Свойства определены в разделе «Определение типа» с помощью фигурных скобок {}, а область действия переменных также определена ранее. Для определения свойств типа для типов значений используется ключевое слово static, а для типов классов - ключевое слово class.

Синтаксис

struct Structname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // return an Int value here
   }
}

enum Enumname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // return an Int value here
   }
}

class Classname {
   class var computedTypeProperty: Int {
      // return an Int value here
   }
}

Запрос и установка свойств

Так же, как свойства экземпляра Свойства типа запрашиваются и устанавливаются с помощью '.' Синтаксис только для типа вместо указания на экземпляр.

struct StudMarks {
   static let markCount = 97
   static var totalCount = 0
   
   var InternalMarks: Int = 0 {
      didSet {
         if InternalMarks > StudMarks.markCount {
            InternalMarks = StudMarks.markCount
         }
         if InternalMarks > StudMarks.totalCount {
            StudMarks.totalCount = InternalMarks
         }
      }
   }
}

var stud1Mark1 = StudMarks()
var stud1Mark2 = StudMarks()

stud1Mark1.InternalMarks = 98
print(stud1Mark1.InternalMarks)

stud1Mark2.InternalMarks = 87
print(stud1Mark2.InternalMarks)

Когда мы запускаем вышеуказанную программу с помощью игровой площадки, мы получаем следующий результат:

97
87