Méthodes Swift
Les méthodes Swift sont des fonctions associées à un type particulier.
En Objective-C, les classes sont le seul type qui peut définir des méthodes. En Swift, cependant, vous pouvez non seulement choisir si vous définissez une class/struct/enum, mais aussi définir de manière flexible des méthodes sur les types que vous créez (class/struct/enum).
Méthodes d'instance
En Swift, les méthodes d'instance sont des méthodes qui appartiennent à des instances d'une classe, d'une structure ou d'un type d'énumération particuliers.
Les méthodes d'instance fournissent les capacités suivantes :
Elles peuvent accéder aux propriétés d'instance et les modifier
Fournir une fonctionnalité liée à l'objectif de l'instance
Les méthodes d'instance doivent être écrites entre les accolades ouvrante et fermante ({}) du type auquel elles appartiennent.
Les méthodes d'instance peuvent accéder implicitement à toutes les autres méthodes d'instance et propriétés du type auquel elles appartiennent.
Les méthodes d'instance ne peuvent être appelées que sur une instance particulière de la classe à laquelle elles appartiennent.
Les méthodes d'instance ne peuvent pas être appelées indépendamment d'une instance existante.
Syntaxe
func funcname(Parameters) -> returntype
{
Statement1
Statement2
……
Statement N
return parameters
}
Exemple
import Cocoa
class Counter {
var count = 0
func increment() {
count += 1
}
func incrementBy(amount: Int) {
count += amount
}
func reset() {
count = 0
}
}
// 初始计数值是0
let counter = Counter()
// 计数值现在是1
counter.increment()
// 计数值现在是6
counter.incrementBy(amount: 5)
print(counter.count)
// 计数值现在是0
counter.reset()
print(counter.count)
La sortie du programme ci-dessus est :
6 0
La classe Counter définit trois méthodes d'instance :
- incrementIncrémenter le compteur de 1 ;
- incrementBy(amount: Int)Incrémente le compteur d'une valeur entière spécifiée ;
- resetRéinitialise le compteur à 0.
CounterLa classe déclare également une propriété variablecountpour suivre la valeur actuelle du compteur.
Noms de paramètres locaux et externes pour les méthodes
Les paramètres de fonction Swift peuvent avoir à la fois un nom local (utilisé dans le corps de la fonction) et un nom externe (utilisé lors de l'appel de la fonction).
Les méthodes en Swift sont extrêmement similaires aux méthodes en Objective-C. Comme en Objective-C, le nom d'une méthode en Swift utilise généralement une préposition pour faire référence au premier paramètre de la méthode, comme with, for, by, etc.
Par défaut, Swift attribue uniquement un nom de paramètre local au nom du premier paramètre ; par défaut, il attribue des noms de paramètres externes aux noms des deuxième et suivants paramètres.
Dans l'exemple suivant, 'no1' est déclaré comme nom de paramètre local en Swift. 'no2' est déclaré comme nom de paramètre externe et est accessible par le code externe.
import Cocoa
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)
La sortie du programme ci-dessus est :
600 320 3666
Spécification des noms de paramètres externes
Nous forçons un nom externe pour le premier paramètre en traitant le nom local comme le nom externe (avant Swift 2.0, le symbole # était utilisé).
Inversement, nous pouvons également utiliser un trait de soulignement (_) pour définir les deuxième et suivants paramètres afin qu'ils ne fournissent pas de nom externe.
import Cocoa
class multiplication {
var count: Int = 0
func incrementBy(first no1: Int, no2: Int) {
count = no1 * no2
print(count)
}
}
let counter = multiplication()
counter.incrementBy(first: 800, no2: 3)
counter.incrementBy(first: 100, no2: 5)
counter.incrementBy(first: 15000, no2: 3)
La sortie du programme ci-dessus est :
2400 500 45000
La propriété self
Chaque instance d’un type possède une propriété implicite appelée self, qui est exactement équivalente à l’instance elle-même.
Vous pouvez utiliser cette propriété implicite self au sein d’une méthode d’instance d’une instance pour faire référence à l’instance actuelle.
import Cocoa
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("Self 内: \(res)")
}
func tot(c: Int) -> Int {
return res - c
}
func result() {
print("结果为: \(tot(c: 20))")
print("结果为: \(tot(c: 50))")
}
}
let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)
pri.result()
sum.result()
La sortie du programme ci-dessus est :
Self 内: 900 Self 内: 1500 结果为: 880 结果为: 850 结果为: 1480 结果为: 1450
Modification des types valeur depuis l’intérieur des méthodes d’instance
En Swift, les structures et les énumérations sont des types valeur. Par défaut, les propriétés d’un type valeur ne peuvent pas être modifiées depuis l’intérieur de ses méthodes d’instance.
Toutefois, si vous avez vraiment besoin de modifier les propriétés d’une structure ou d’une énumération dans une méthode spécifique, vous pouvez choisir de marquer la méthode comme mutating. La méthode peut alors modifier ses propriétés depuis l’intérieur de la méthode ; et toutes les modifications qu’elle effectue sont conservées dans la structure d’origine lorsque la méthode se termine.
Une méthode peut également affecter une toute nouvelle instance à sa propriété implicite self, et cette nouvelle instance remplacera l’instance d’origine lorsque la méthode se termine.
import Cocoa
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)
La sortie du programme ci-dessus est :
9 15 270 450 81000 135000
Affectation à self dans une méthode mutating
Une méthode mutating peut affecter une instance entièrement nouvelle à la propriété implicite self.
import Cocoa
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)
La sortie du programme ci-dessus est :
39 65
Méthodes de type
Les méthodes d’instance sont des méthodes appelées par une instance d’un type. Vous pouvez également définir des méthodes qui sont appelées par le type lui-même, et ces méthodes sont appelées méthodes de type.
Pour déclarer des méthodes de type pour les structures et les énumérations, ajoutez le mot-clé static avant le mot-clé func de la méthode. Les classes peuvent utiliser le mot-clé class pour permettre aux sous-classes de redéfinir l’implémentation de la méthode par la superclasse.
Les méthodes de type sont appelées en utilisant la syntaxe avec point (.), tout comme les méthodes d’instance.
import Cocoa
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)
La sortie du programme ci-dessus est :
35 5Autres extensions