Swift - metody

W języku Swift 4 Funkcje powiązane z określonymi typami nazywane są metodami. W Objective C klasy są używane do definiowania metod, podczas gdy język Swift 4 zapewnia użytkownikowi elastyczność w zakresie posiadania metod dla klas, struktur i wyliczeń.

Metody instancji

W języku Swift 4 do klas, struktur i wyliczeń można uzyskać dostęp za pośrednictwem metod instancji.

Metody instancji zapewniają funkcjonalność

Dostęp i modyfikowanie właściwości instancji
funkcjonalność związana z potrzebą instancji

Metoda instancji może być zapisana w nawiasach klamrowych {}. Ma niejawny dostęp do metod i właściwości wystąpienia typu. Gdy zostanie wywołana konkretna instancja typu, uzyska ona dostęp do tej konkretnej instancji.

Składnia

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

Przykład

class calculations {
   let a: Int
   let b: Int
   let res: Int

   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
   }
   
   func tot(c: Int) -> Int {
      return res - c
   }
   
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}
let pri = calculations(a: 600, b: 300)
pri.result()

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

Result is: 880
Result is: 850

Class Calculations definiuje dwie metody instancji -

init () jest zdefiniowany w celu dodania dwóch liczb a i b i zapisania ich w wyniku 'res'
tot () służy do odejmowania wartości „res” od przekazywania wartości „c”

Wreszcie, aby wydrukować metody obliczeń z wartościami a i b, jest wywoływana. Dostęp do metod instancji uzyskuje się za pomocą „.” składnia kropkowa

Nazwy parametrów lokalnych i zewnętrznych

Funkcje Swift 4 opisują zarówno lokalne, jak i globalne deklaracje swoich zmiennych. Podobnie, konwencje nazewnictwa metod Swift 4 są również podobne do konwencji Celu C. Jednak właściwości deklaracji nazw parametrów lokalnych i globalnych są różne dla funkcji i metod. Pierwszy parametr w Swift 4 jest określany przez nazwy przyimków jako „with”, „for” i „by” w celu ułatwienia dostępu do konwencji nazewnictwa.

Swift 4 zapewnia elastyczność metod poprzez deklarowanie nazwy pierwszego parametru jako lokalnych nazw parametrów, a pozostałe nazwy parametrów jako nazwy globalne. Tutaj „no1” jest zadeklarowane przez metody Swift 4 jako lokalne nazwy parametrów. „no2” jest używane do deklaracji globalnych i dostępne za pośrednictwem programu.

class division {
   var count: Int = 0
   func incrementBy(no1: Int, no2: Int) {
      count = no1 / no2
      print(count)
   }
}

let counter = division()
counter.incrementBy(no1: 1800, no2: 3)
counter.incrementBy(no1: 1600, no2: 5)
counter.incrementBy(no1: 11000, no2: 3)

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

600
320
3666

Nazwa parametru zewnętrznego z # i _ Symbolem

Mimo że metody Swift 4 zapewniają nazwy pierwszych parametrów dla deklaracji lokalnych, użytkownik ma możliwość modyfikowania nazw parametrów z deklaracji lokalnych na globalne. Można to zrobić, poprzedzając symbol „#” nazwą pierwszego parametru. W ten sposób pierwszy parametr jest dostępny globalnie w modułach.

Gdy użytkownik potrzebuje dostępu do kolejnych nazw parametrów z nazwą zewnętrzną, nazwa metody jest nadpisywana za pomocą symbolu „_”.

class multiplication {
   var count: Int = 0
   func incrementBy(no1: Int, no2: Int) {
      count = no1 * no2
      print(count)
   }
}

let counter = multiplication()

counter.incrementBy(no1: 800, no2: 3)
counter.incrementBy(no1: 100, no2: 5)
counter.incrementBy(no1: 15000, no2: 3)

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

2400
500
45000

Własność własna w metodach

Metody mają niejawną właściwość znaną jako „self” dla wszystkich jej zdefiniowanych wystąpień typu. Właściwość „Self” służy do odwoływania się do bieżących instancji w celu określenia ich metod.

class calculations {
   let a: Int
   let b: Int
   let res: Int

   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
      print("Inside Self Block: \(res)")
   }
   
   func tot(c: Int) -> Int {
      return res - c
   }
   
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}

let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)

pri.result()
sum.result()

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

Inside Self Block: 900
Inside Self Block: 1500
Result is: 880
Result is: 850
Result is: 1480
Result is: 1450

Modyfikowanie typów wartości z metod instancji

W języku Swift 4 struktury i wyliczenia należą do typów wartości, których nie można zmienić za pomocą metod instancji. Jednak język Swift 4 zapewnia elastyczność w modyfikowaniu typów wartości poprzez „mutowanie” zachowania. Mutate dokona wszelkich zmian w metodach instancji i powróci do pierwotnej postaci po wykonaniu metody. Ponadto właściwość „self” tworzy nową instancję dla jej niejawnej funkcji i zastępuje istniejącą metodę po jej wykonaniu

struct area {
   var length = 1
   var breadth = 1
   
   func area() -> Int {
      return length * breadth
   }
   mutating func scaleBy(res: Int) {
      length *= res
      breadth *= res
      print(length)
      print(breadth)
   }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)

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

Własność metody mutacji

Mutowanie metod w połączeniu z właściwością „self” przypisuje nową instancję do zdefiniowanej metody.

struct area {
   var length = 1
   var breadth = 1
   func area() -> Int {
      return length * breadth
   }
   mutating func scaleBy(res: Int) {
      self.length *= res
      self.breadth *= res
      print(length)
      print(breadth)
   }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 13)

Uruchamiając powyższy program za pomocą placu zabaw, otrzymujemy następujący wynik. -

39
65

Metody typu

Gdy wywoływana jest określona instancja metody, jest ona wywoływana jako metoda instancji; a kiedy metoda wywołuje określony typ metody, jest nazywana „Metody typu”. Metody typu dla „klas” są definiowane za pomocą słowa kluczowego „func”, a struktury i metody typu wyliczeń są definiowane za pomocą słowa kluczowego „static” przed słowem kluczowym „func”.

Metody typu są wywoływane i dostępne przez '.' składnia, w której zamiast wywoływać określoną instancję, wywoływana jest cała metoda.

class Math {
   class func abs(number: Int) -> Int {
      if number < 0 {
         return (-number)
      } else {
         return number
      }
   }
}

struct absno {
   static func abs(number: Int) -> Int {
      if number < 0 {
         return (-number)
      } else {
         return number
      }
   }
}

let no = Math.abs(number: -35)
let num = absno.abs(number: -5)

print(no)
print(num)

Uruchamiając powyższy program za pomocą placu zabaw, otrzymujemy następujący wynik. -

35
5