Swift - Właściwości

Język Swift 4 zapewnia właściwości dla klasy, wyliczenia lub struktury w celu skojarzenia wartości. Właściwości można dalej podzielić na Właściwości przechowywane i Właściwości obliczone.

Różnica między właściwościami przechowywanymi i obliczonymi

Majątek składowany	Obliczona właściwość
Przechowuj wartości stałe i zmienne jako instancję	Oblicz wartość, zamiast ją przechowywać
Dostarczane przez klasy i struktury	Dostarczane przez klasy, wyliczenia i struktury

Zarówno właściwości Stored, jak i Computed są skojarzone z typem instancji. Gdy właściwości są skojarzone z wartościami typu, jest to definiowane jako „Właściwości typu”. Właściwości przechowywane i obliczane są zwykle skojarzone z wystąpieniami określonego typu. Jednak właściwości mogą być również skojarzone z samym typem. Takie właściwości są znane jako właściwości typu. Korzysta się również z obserwatorów nieruchomości

Aby obserwować wartość przechowywanych właściwości
Aby obserwować właściwość dziedziczonej podklasy pochodzącej z nadklasy

Przechowywane właściwości

Swift 4 wprowadza koncepcję Stored Property do przechowywania wystąpień stałych i zmiennych. Przechowywane właściwości stałych są definiowane przez słowo kluczowe „let”, a przechowywane właściwości zmiennych za pomocą słowa kluczowego „var”.

Podczas definiowania Właściwość przechowywana zapewnia `` wartość domyślną ''
Podczas inicjalizacji użytkownik może inicjalizować i modyfikować wartości początkowe

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

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

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

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

67
3.1415

Rozważ następujący wiersz w powyższym kodzie -

let pi = 3.1415

Tutaj zmienna pi jest inicjalizowana jako przechowywana wartość właściwości z instancją pi = 3,1415. Tak więc za każdym razem, gdy odwołujemy się do instancji, będzie ona sama przechowywać wartość 3,1415.

Inną metodą przechowywania właściwości jest posiadanie stałych struktur. Zatem cała instancja struktur będzie traktowana jako „Przechowywane właściwości stałych”.

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

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

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

Zamiast ponownej inicjalizacji „liczby” do 8,7 zwróci komunikat o błędzie wskazujący, że „liczba” jest zadeklarowana jako stała.

Leniwa nieruchomość składowana

Swift 4 zapewnia elastyczną właściwość o nazwie „Lazy Stored Property”, w której nie oblicza wartości początkowych, gdy zmienna jest inicjowana po raz pierwszy. Modyfikator „leniwy” jest używany przed deklaracją zmiennej, aby był przechowywany jako leniwa właściwość.

Leniwe właściwości są używane -

Aby opóźnić tworzenie obiektów.
Gdy właściwość jest zależna od innych części klasy, które nie są jeszcze znane

class sample {
   lazy var no = number()    // `var` declaration is required.
}

class number {
   var name = "Swift 4"
}

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

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

Swift 4

Zmienne instancji

W celu C właściwości przechowywane mają również zmienne instancji do celów kopii zapasowej w celu przechowywania wartości zadeklarowanych we właściwości przechowywanej.

Swift 4 integruje obie te koncepcje w jednej deklaracji „przechowywanej własności”. Zamiast posiadania odpowiedniej zmiennej instancji i wartości kopii zapasowej „właściwość przechowywana” zawiera wszystkie zintegrowane informacje zdefiniowane w jednym miejscu na temat właściwości zmiennych według nazwy zmiennej, typu danych i funkcji zarządzania pamięcią.

Obliczone właściwości

Zamiast przechowywać wartości obliczone, właściwości zapewniają metodę pobierającą i opcjonalną metodę ustawiającą do pobierania i ustawiania innych właściwości i wartości pośrednio.

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)

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

(150.0, 75.0)
-150.0
-65.0

Gdy obliczona właściwość pozostawi nową wartość jako niezdefiniowaną, wartość domyślna zostanie ustawiona dla tej konkretnej zmiennej.

Obliczone właściwości jako właściwości tylko do odczytu

Właściwość tylko do odczytu we właściwości obliczonej jest definiowana jako właściwość z funkcją pobierającą, ale bez metody ustawiającej. Jest zawsze używany do zwracania wartości. Dostęp do zmiennych dalej uzyskuje się poprzez „.” Składnia, ale nie można jej ustawić na inną wartość.

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"]!)

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

Swift 4 Properties
3.09

Obliczone właściwości jako obserwatory właściwości

W języku Swift 4 do obserwowania wartości właściwości i reagowania na nie używane są obserwatory właściwości. Za każdym razem, gdy ustawiane są wartości właściwości, wywoływane są obserwatory właściwości. Oprócz leniwych przechowywanych właściwości możemy dodawać obserwatory właściwości do właściwości „dziedziczonej” za pomocą metody „przesłaniania”.

Obserwatory właściwości mogą być definiowane przez jedną z nich

Przed zapisaniem wartości - willset
Po zapisaniu nowej wartości - didset
Gdy właściwość jest ustawiona w inicjatorze, nie można wywołać obserwatorów willset i 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

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

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

Zmienne lokalne i globalne

Do obliczania i obserwacji właściwości deklarowane są zmienne lokalne i globalne.

Zmienne lokalne	Zmienne globalne
Zmienne zdefiniowane w ramach funkcji, metody lub kontekstu zamknięcia.	Zmienne zdefiniowane poza kontekstem funkcji, metody, zamknięcia lub typu.
Służy do przechowywania i pobierania wartości.	Służy do przechowywania i pobierania wartości.
Przechowywane właściwości służą do pobierania i ustawiania wartości.	Przechowywane właściwości służą do pobierania i ustawiania wartości.
Wykorzystywane są również obliczone właściwości.	Wykorzystywane są również obliczone właściwości.

Właściwości typu

Właściwości są zdefiniowane w sekcji Definicja typu za pomocą nawiasów klamrowych {}, a zakres zmiennych został również zdefiniowany wcześniej. Do definiowania właściwości typu dla typów wartości używane jest słowo kluczowe „static”, a dla typów klas - słowo kluczowe „class”.

Składnia

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

Zapytania i ustawianie właściwości

Podobnie jak właściwości instancji Właściwości typu są odpytywane i ustawiane za pomocą „.” Składnia dotyczy samego typu zamiast wskazywać na instancję.

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)

Gdy uruchomimy powyższy program za pomocą placu zabaw, otrzymamy następujący wynik -

97
87