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
5
Autres extensions