Méthode rapide


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

En Objective-C, les classes sont les seuls types qui peuvent définir des méthodes. Mais dans Swift, vous pouvez non seulement choisir de définir une classe/structure/énumération, mais également définir de manière flexible des méthodes sur les types (classes/structures/énumérations) que vous créez.

Méthodes d'instance

Dans le langage 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 spécifique.

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

  • peuvent accéder aux propriétés de l'instance et les modifier.

  • Fournit des fonctionnalités liées à l'objectif de l'instance

Les méthodes d'instance doivent être écrites entre les accolades environnantes ({}) du type auquel elles appartiennent.

Une méthode d'instance a un accès implicite à toutes les autres méthodes d'instance et propriétés de son type.

Une méthode d'instance ne peut être appelée que par une instance spécifique de la classe à laquelle elle appartient.

Les méthodes d'instance ne peuvent pas être appelées indépendamment de l'instance existante.

Syntaxe

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

Instance

import Cocoa

class Counter {
    var count = 0
    func increment() {
        count++
    }
    func incrementBy(amount: Int) {
        count += amount
    }
    func reset() {
        count = 0
    }
}
// 初始计数值是0
let counter = Counter()

// 计数值现在是1
counter.increment()

// 计数值现在是6
counter.incrementBy(5)
print(counter.count)

// 计数值现在是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'instance :

  • incrementIncrémente le compteur de un

  • incrementBy(amount: Int)Incrémente le compteur d'une valeur entière spécifiée

  • resetRemettre le compteur à 0.

CounterCette classe déclare également un attribut mutable count, qui est utilisé pour garder une trace de la valeur actuelle du compteur.

Nom du paramètre local et nom du paramètre externe de la méthode

Les paramètres de la 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 function

Les méthodes en Swift sont très similaires aux méthodes en Objective-C Comme en Objective-C, le nom d'une méthode en Swift pointe généralement vers le premier paramètre de la méthode avec une préposition, telle que : with. , for. , by, etc.

Swift donne uniquement au premier nom de paramètre de la méthode un nom de paramètre local par défaut, il donne également au deuxième nom de paramètre et aux suivants les noms de paramètres globaux suivants ; , 'no1' est déclaré comme nom de paramètre local dans Swift. 'no2' est utilisé pour la déclaration globale et l'accès via des programmes externes 

import Cocoa

class division {
    var count: Int = 0
    func incrementBy(no1: Int, no2: Int) {
        count = no1 / no2
        print(count)
    }
}

let counter = division()
counter.incrementBy(1800, no2: 3)
counter.incrementBy(1600, no2: 5)
counter.incrementBy(11000, no2: 3)

La sortie du programme ci-dessus est : 

600
320
3666

. Que ce soit. Fournir des paramètres de nom externe

Nous forçons l'ajout d'un nom externe au premier paramètre pour utiliser ce nom local comme nom externe (avant Swift 2.0, le signe # était utilisé au contraire). utilisez des traits de soulignement. (_) Définissez le deuxième paramètre et les suivants sans fournir de nom externe. Chaque instance du type 🎜>

a un attribut implicite appelé self qui est complètement équivalent à l'instance elle-même. Vous pouvez utiliser cet attribut self implicite dans la méthode d'instance d'une instance. Faites référence à l'instance actuelle 

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)

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

2400
500
45000

Modifier le type de valeur dans la méthode d'instance

Les structures et les énumérations en langage Swift sont des types de valeur. En général, les propriétés d'un type valeur ne peuvent pas être modifiées dans ses méthodes d'instance.

Cependant, si vous avez vraiment besoin de modifier les propriétés de la structure ou de l'énumération dans une méthode spécifique, vous pouvez choisir de muter la méthode, et la méthode peut alors modifier ses propriétés depuis l'intérieur de la méthode ; il restera dans la structure d'origine à la fin de la méthode. La méthode

peut également attribuer une nouvelle instance à son attribut self implicite. Cette nouvelle instance remplacera l'instance d'origine une fois la méthode terminée. 

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(20))")
        print("结果为: \(tot(50))")
    }
}

let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)

pri.result()
sum.result()

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

Self 内: 900
Self 内: 1500
结果为: 880
结果为: 850
结果为: 1480
结果为: 1450

Attribuer une valeur à self dans la méthode variable

La méthode variable peut attribuer un nouvelle valeur à l’instance d’attribut implicite. 

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(3)
val.scaleBy(30)
val.scaleBy(300)

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

9
15
270
450
81000
135000

Méthode de type

La méthode d'instance est une méthode appelée par une instance du type. définir le type La méthode appelée par elle-même est appelée méthode de type.

Déclarez les méthodes de type des structures et des énumérations, et 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 remplacer les méthodes d'implémentation de la classe parent.

Les méthodes de type sont appelées avec la syntaxe point (.) tout comme les méthodes d'instance. 

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

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

39
65