Swift - Methoden

In der Sprache Swift 4 werden Funktionen, die bestimmten Typen zugeordnet sind, als Methoden bezeichnet. In Ziel C werden Klassen zum Definieren von Methoden verwendet, während die Sprache Swift 4 dem Benutzer Flexibilität bietet, Methoden für Klassen, Strukturen und Aufzählungen zu haben.

Instanzmethoden

In der Sprache Swift 4 wird über die Instanzmethoden auf Klassen-, Struktur- und Aufzählungsinstanzen zugegriffen.

Instanzmethoden bieten Funktionalität

Zugriff auf und Änderung von Instanzeigenschaften
Funktionalität in Bezug auf den Bedarf der Instanz

Die Instanzmethode kann in die geschweiften Klammern {} geschrieben werden. Es hat impliziten Zugriff auf Methoden und Eigenschaften der Typinstanz. Wenn eine bestimmte Instanz des Typs aufgerufen wird, erhält sie Zugriff auf diese bestimmte Instanz.

Syntax

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

Beispiel

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()

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

Result is: 880
Result is: 850

Klassenberechnungen definieren zwei Instanzmethoden -

init () fügt zwei Zahlen a und b hinzu und speichert sie im Ergebnis 'res'.
tot () wird verwendet, um das 'res' vom Übergeben des 'c'-Werts zu subtrahieren

Schließlich wird das Drucken der Berechnungsmethoden mit Werten für a und b aufgerufen. Auf Instanzmethoden wird mit '.' Punktsyntax

Lokale und externe Parameternamen

Swift 4-Funktionen beschreiben sowohl lokale als auch globale Deklarationen für ihre Variablen. In ähnlicher Weise ähneln die Namenskonventionen für Swift 4-Methoden auch denen für Ziel C. Die Merkmale lokaler und globaler Parameternamendeklarationen unterscheiden sich jedoch für Funktionen und Methoden. Die ersten Parameter in Swift 4 werden durch Präpositionennamen als 'with', 'for' und 'by' bezeichnet, um den Zugriff auf Namenskonventionen zu erleichtern.

Swift 4 bietet die Flexibilität bei Methoden, indem der erste Parametername als lokale Parameternamen und die verbleibenden Parameternamen als globale Parameternamen deklariert werden. Hier wird 'no1' von Swift 4-Methoden als lokale Parameternamen deklariert. 'no2' wird für globale Deklarationen verwendet und im gesamten Programm aufgerufen.

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)

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

600
320
3666

Externer Parametername mit # und _ Symbol

Obwohl Swift 4-Methoden erste Parameternamen für lokale Deklarationen bereitstellen, kann der Benutzer die Parameternamen von lokalen zu globalen Deklarationen ändern. Dies kann durch Voranstellen des Symbols '#' mit dem ersten Parameternamen erfolgen. Auf diese Weise kann in allen Modulen global auf den ersten Parameter zugegriffen werden.

Wenn der Benutzer mit einem externen Namen auf die nachfolgenden Parameternamen zugreifen muss, wird der Methodenname mithilfe des Symbols '_' überschrieben.

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)

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

2400
500
45000

Selbsteigenschaft in Methoden

Methoden haben eine implizite Eigenschaft, die für alle definierten Typinstanzen als "self" bezeichnet wird. Die Eigenschaft 'Self' wird verwendet, um die aktuellen Instanzen für die definierten Methoden zu referenzieren.

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()

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

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

Ändern von Werttypen aus Instanzmethoden

In Swift 4 gehören Sprachstrukturen und Aufzählungen zu Werttypen, die mit ihren Instanzmethoden nicht geändert werden können. Die Sprache Swift 4 bietet jedoch Flexibilität, um die Werttypen durch "Mutieren" des Verhaltens zu ändern. Mutate nimmt alle Änderungen an den Instanzmethoden vor und kehrt nach Ausführung der Methode zum ursprünglichen Formular zurück. Außerdem wird durch die Eigenschaft 'self' eine neue Instanz für ihre implizite Funktion erstellt und ersetzt die vorhandene Methode nach ihrer Ausführung

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)

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis:

Selbsteigenschaft für Mutationsmethode

Mutierende Methoden in Kombination mit der Eigenschaft 'self' weisen der definierten Methode eine neue Instanz zu.

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)

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis. - -

39
65

Typ Methoden

Wenn eine bestimmte Instanz einer Methode aufgerufen wird, wird sie als Instanzmethode aufgerufen. und wenn die Methode einen bestimmten Typ einer Methode aufruft, wird sie als 'Typmethoden' bezeichnet. Typmethoden für 'Klassen' werden durch das Schlüsselwort 'func' definiert, und Strukturen und Aufzählungen Typmethoden werden mit dem Schlüsselwort 'static' vor dem Schlüsselwort 'func' definiert.

Typmethoden werden von '.' Aufgerufen und aufgerufen. Syntax, bei der anstelle des Aufrufs einer bestimmten Instanz die gesamte Methode aufgerufen wird.

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)

Wenn wir das obige Programm auf einem Spielplatz ausführen, erhalten wir das folgende Ergebnis. - -

35
5