Méthodes Swift

Les méthodes Swift sont associées à certains types spécifiques

Dans Objective-Dans C, la classe est le seul type capable de définir des méthodes. Mais en Swift, vous pouvez choisir de définir ou non une classe/Structure/Énumération, et peuvent être flexibles dans les types que vous créez (classe/Structure/et définir des méthodes sur des énumérations).

Méthodes d'exemple

En Swift, les méthodes d'exemple appartiennent à un exemple spécifique de classe, de structure ou d'énumération.

Les méthodes d'exemple fournissent les méthodes suivantes :

• Accéder et modifier les propriétés de l'exemple

• Fournir des fonctionnalités liées à l'objectif de l'exemple

Les méthodes d'exemple doivent être écrites entre les accolades ({}) de leur type.

Les méthodes d'exemple peuvent accéder implicitement à toutes les autres méthodes et propriétés de leur type.

Les méthodes d'exemple ne peuvent être appelées que par un exemple spécifique de la classe à laquelle elles appartiennent.

Les méthodes d'exemple ne peuvent pas être appelées indépendamment des exemples existants.

Syntaxe

func funcname(Parameters) -> type de retour
{
    Énoncé1
    Énoncé2
    ……
    Énoncé N
    retourner les paramètres
}

Exemple en ligne

import Cocoa
class Counter {
    var count = 0
    func increment() {
        count += 1
    }
    func incrementBy(amount: Int) {
        count += amount
    }
    func reset() {
        count = 0
    }
}
// La valeur initiale du compteur est 0
let counter = Counter()
// La valeur du compteur est maintenant1
counter.increment()
// La valeur du compteur est maintenant6
counter.incrementBy(amount: 5)
print(counter.count)
// La valeur du compteur est maintenant 0
counter.reset()
print(counter.count)

Le résultat de l'exécution du programme ci-dessus est :

6
0

La classe Counter définit trois méthodes d'exemple :

• increment Incrémente le compteur de 1 Incrémente;
• incrementBy(amount: Int) Incrémente le compteur d'une valeur entière spécifiée;
• reset Réinitialise le compteur à 0.

Counter Cette classe déclare également une propriété mutável countpour suivre la valeur actuelle du compteur.

Noms de paramètres locaux et externes des méthodes

Les paramètres de fonction en Swift peuvent avoir à la fois un nom local (à utiliser à l'intérieur de la fonction) et un nom externe (à utiliser lors de l'appel de la fonction

Les méthodes en Swift et Objective-Les méthodes en C sont extrêmement similaires. Comme dans Objective-Comme en C, le nom des méthodes en Swift est généralement précédé d'un préposition pour le premier paramètre de la méthode, par exemple : with, for, by, etc.

Swift attribue par défaut un nom de paramètre local au premier paramètre d'une méthode; par défaut, les noms de paramètres locaux sont attribués aux second et aux paramètres suivants.

Dans l'exemple suivant, 'non1' est déclaré comme nom de paramètre local en Swift. 'non2' est utilisé pour les déclarations globales et pour l'accès par des programmes externes.

import Cocoa
class division {
    var count: Int = 0
    func incrementBy(non1: Int, non2: Int) {
        count = non1 / non2
        print(count)
    }
}
let counter = division()
counter.incrementBy(non1: 1800, non2: 3)
counter.incrementBy(non1: 1600, non2: 5)
counter.incrementBy(non1: 11000, non2: 3)

Le résultat de l'exécution du programme ci-dessus est :

600
320
3666

Configuration de l'attribution des noms externes

Nous forçons l'ajout d'un nom externe au premier paramètre pour utiliser ce nom local en tant que nom externe (Swift 2.0 avant l'utilisation du symbole #).

Au contraire, nous pouvons également utiliser le tiret bas (_ _) pour ne pas fournir de nom externe pour le second et les paramètres suivants.

import Cocoa
class multiplication {
    var count: Int = 0
    func incrementBy(first non1: Int, non2: Int) {
        count = non1 * non2
        print(count)
    }
}
let counter = multiplication()
counter.incrementBy(first : 800, non2: 3)
counter.incrementBy(first : 100, non2: 5)
counter.incrementBy(first : 15000, non2: 3)

Le résultat de l'exécution du programme ci-dessus est :

2400
500
45000

Attribut self

Chaque instance d'un type a un attribut implicite appelé self, self est complètement équivalent à l'instance elle-même.

Vous pouvez utiliser l'attribut implicite self dans une méthode d'instance pour faire référence à l'instance actuelle.

import Cocoa
class calculs {
    let a: Int
    let b: Int
    let res: Int
    init(a: Int, b: Int) {
        self.a = a
        self.b = b
        res = a + b
        print("Dans Self : \(res)")
    }
    func tot(c: Int) -> Int {
        retourne res - c
    }
    func result() {
        print("Résultat : \(tot(c : 20))
        print("Résultat : \(tot(c : 50))
    }
}
let pri = calculs(a : 600, b : 300)
let sum = calculs(a : 1200, b : 300)
pri.result()
sum.result()

Le résultat de l'exécution du programme ci-dessus est :

Dans Self : 900
Dans Self : 1500
Résultat : 880
Résultat : 850
Résultat : 1480
Résultat : 1450

Modification des types de valeur dans les méthodes d'instance

Les structures et les enumerations en Swift sont des types de valeur. En règle générale, les propriétés des types de valeur ne peuvent pas être modifiées dans leurs méthodes d'instance.

Mais si vous avez vraiment besoin de modifier les propriétés d'une structure ou d'une enumeration dans une méthode spécifique, vous pouvez choisir la méthode mutante (mutating) et la méthode peut alors modifier ses propriétés à partir de l'intérieur ; et toutes les modifications qu'elle fait sont conservées dans l'original à la fin de la méthode.

La méthode peut également assigner une nouvelle instance complète à l'attribut implicite self, cette nouvelle instance remplaçant l'instance originale à la fin de la méthode.

import Cocoa
struct aire {
    var longueur = 1
    var largeur = 1
    func aire() -> Int {
        retourne longueur * largeur
    }
    mutant func scaleBy(res: Int) {
        longueur *= res
        largeur *= res
        print(longueur)
        print(largeur)
    }
}
var val = aire(longueur: 3, largeur: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)

Le résultat de l'exécution du programme ci-dessus est :

9
15
270
450
81000
135000

Affectation de self dans une méthode mutante

Les méthodes mutantes peuvent assigner à l'attribut implicite self une nouvelle instance complète.

import Cocoa
struct aire {
    var longueur = 1
    var largeur = 1
    func aire() -> Int {
        retourne longueur * largeur
    }
    mutant func scaleBy(res: Int) {
        self.longueur *= res
        self.largeur *= res
        print(longueur)
        print(largeur)
    }
}
var val = aire(longueur: 3, largeur: 5)
val.scaleBy(res: 13)

Le résultat de l'exécution du programme ci-dessus est :

39
65

Méthode de type

Les méthodes d'exemple sont appelées par une instance du type, vous pouvez également définir des méthodes appelées par le type lui-même, qui sont appelées méthodes de type.

Déclarez les méthodes de type des structures et des enums en ajoutant la cléword static avant le mot-clé func. Les classes peuvent utiliser la cléword class pour permettre aux sous-classes de redéfinir l'implémentation des parents.

Les méthodes de type et les méthodes d'exemple sont appelées avec la syntaxe du point (.).

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)

Le résultat de l'exécution du programme ci-dessus est :

35
5