Swift - Méthodes

En langage Swift 4, les fonctions associées à des types particuliers sont appelées méthodes. En Objective C, les classes sont utilisées pour définir des méthodes, tandis que le langage Swift 4 offre à l'utilisateur la flexibilité d'avoir des méthodes pour les classes, les structures et les énumérations.

Méthodes d'instance

En langage Swift 4, les instances Classes, Structures et Enumeration sont accessibles via les méthodes d'instance.

Les méthodes d'instance fournissent des fonctionnalités

Pour accéder et modifier les propriétés des instances
fonctionnalité liée au besoin de l'instance

La méthode d'instance peut être écrite à l'intérieur des {} accolades. Il a un accès implicite aux méthodes et propriétés de l'instance de type. Lorsqu'une instance spécifique du type est appelée, elle aura accès à cette instance particulière.

Syntaxe

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

Exemple

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

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Result is: 880
Result is: 850

Les calculs de classe définissent deux méthodes d'instance -

init () est défini pour ajouter deux nombres a et b et les stocker dans le résultat 'res'
tot () est utilisé pour soustraire le 'res' de passer la valeur 'c'

Enfin, pour imprimer les méthodes de calculs avec des valeurs pour a et b est appelée. Les méthodes d'instance sont accessibles avec '.' syntaxe de point

Noms des paramètres locaux et externes

Les fonctions Swift 4 décrivent les déclarations locales et globales pour leurs variables. De même, les conventions de dénomination des méthodes Swift 4 ressemblent également à celles de l'Objectif C. Mais les caractéristiques des déclarations de noms de paramètres locaux et globaux sont différentes pour les fonctions et les méthodes. Le premier paramètre dans Swift 4 est référencé par les noms de préposition comme «avec», «pour» et «par» pour des conventions de dénomination faciles d'accès.

Swift 4 offre la flexibilité des méthodes en déclarant le premier nom de paramètre en tant que noms de paramètres locaux et les noms de paramètres restants comme des noms de paramètres globaux. Ici, «no1» est déclaré par les méthodes Swift 4 comme noms de paramètres locaux. «no2» est utilisé pour les déclarations globales et accessible via le programme.

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)

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

600
320
3666

Nom du paramètre externe avec symbole # et _

Même si les méthodes Swift 4 fournissent les premiers noms de paramètres pour les déclarations locales, l'utilisateur a la possibilité de modifier les noms de paramètres des déclarations locales aux déclarations globales. Cela peut être fait en préfixant le symbole «#» avec le premier nom de paramètre. Ce faisant, le premier paramètre est accessible globalement à travers les modules.

Lorsque l'utilisateur a besoin d'accéder aux noms de paramètres suivants avec un nom externe, le nom des méthodes est remplacé à l'aide du symbole «_».

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)

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

2400
500
45000

Propriété de soi dans les méthodes

Les méthodes ont une propriété implicite appelée «self» pour toutes ses instances de type définies. La propriété 'Self' est utilisée pour référencer les instances actuelles pour ses méthodes définies.

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

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

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

Modification des types de valeur à partir des méthodes d'instance

Dans Swift 4, les structures et les énumérations appartiennent à des types de valeur qui ne peuvent pas être modifiés par ses méthodes d'instance. Cependant, le langage Swift 4 offre la flexibilité de modifier les types de valeur en «mutant» le comportement. Mutate apportera toutes les modifications aux méthodes d'instance et reviendra au formulaire d'origine après l'exécution de la méthode. De plus, par la propriété 'self', une nouvelle instance est créée pour sa fonction implicite et remplacera la méthode existante après son exécution

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)

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Propriété propre pour la méthode de mutation

Les méthodes mutantes combinées à la propriété «self» attribuent une nouvelle instance à la méthode définie.

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)

Lorsque nous exécutons le programme ci-dessus en utilisant Playground, nous obtenons le résultat suivant. -

39
65

Méthodes de type

Lorsqu'une instance particulière d'une méthode est appelée, elle est appelée en tant que méthode Instance; et lorsque la méthode appelle un type particulier de méthode, elle est appelée «Méthodes de type». Les méthodes de type pour les 'classes' sont définies par le mot clé 'func' et les méthodes de type structures et énumérations sont définies avec le mot clé 'static' avant le mot clé 'func'.

Les méthodes de type sont appelées et accessibles par '.' syntaxe où au lieu d'appeler une instance particulière, la méthode entière est appelée.

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)

Lorsque nous exécutons le programme ci-dessus en utilisant Playground, nous obtenons le résultat suivant. -

35
5