Swift Language
Les fonctions

Utilisation de base

Les fonctions peuvent être déclarées sans paramètre ni valeur de retour. La seule information requise est un nom ( hello dans ce cas).

func hello()
{
    print("Hello World")
}

Appelez une fonction sans paramètre en écrivant son nom suivi d'une paire de parenthèses vide.

hello()
//output: "Hello World"

Fonctions avec paramètres

Les fonctions peuvent prendre des paramètres pour que leurs fonctionnalités puissent être modifiées. Les paramètres sont donnés sous forme de liste séparée par des virgules, leurs types et noms étant définis.

func magicNumber(number1: Int)
{
    print("\(number1) Is the magic number")
}

Remarque: La syntaxe \(number1) est l' interpolation de base des chaînes et permet d'insérer le nombre entier dans la chaîne.

Les fonctions avec paramètres sont appelées en spécifiant la fonction par nom et en fournissant une valeur d'entrée du type utilisé dans la déclaration de fonction.

magicNumber(5)
//output: "5 Is the magic number
let example: Int = 10
magicNumber(example)
//output: "10 Is the magic number"

Toute valeur de type Int aurait pu être utilisée.

func magicNumber(number1: Int, number2: Int)
{
    print("\(number1 + number2) Is the magic number")
}

Lorsqu'une fonction utilise plusieurs paramètres, le nom du premier paramètre n'est pas requis pour le premier mais concerne les paramètres suivants.

let ten: Int = 10
let five: Int = 5
magicNumber(ten,number2: five)
//output: "15 Is the magic number"

Utilisez des noms de paramètres externes pour rendre les appels de fonctions plus lisibles.

func magicNumber(one number1: Int, two number2: Int)
{
    print("\(number1 + number2) Is the magic number")
}

let ten: Int = 10
let five: Int = 5
magicNumber(one: ten, two: five)

La définition de la valeur par défaut dans la déclaration de fonction vous permet d'appeler la fonction sans donner aucune valeur d'entrée.

func magicNumber(one number1: Int = 5, two number2: Int = 10)
{
    print("\(number1 + number2) Is the magic number")
}

magicNumber()
//output: "15 Is the magic number"

Valeurs de retour

Les fonctions peuvent renvoyer des valeurs en spécifiant le type après la liste des paramètres.

func findHypotenuse(a: Double, b: Double) -> Double
{
    return sqrt((a * a) + (b * b))
}

let c = findHypotenuse(3, b: 5)
//c = 5.830951894845301

Les fonctions peuvent également renvoyer plusieurs valeurs à l'aide de tuples.

func maths(number: Int) -> (times2: Int, times3: Int)
{
    let two = number * 2
    let three = number * 3
    return (two, three)
}
let resultTuple = maths(5)
//resultTuple = (10, 15)

Erreurs de lancement

Si vous voulez une fonction pour pouvoir lancer des erreurs, vous devez ajouter le throws mot - clé après les parenthèses qui maintiennent les arguments:

func errorThrower()throws -> String {}

Lorsque vous souhaitez générer une erreur, utilisez le mot-clé throw :

func errorThrower()throws -> String {
  if true {
    return "True"
  } else {
    // Throwing an error
    throw Error.error 
  }
}

Si vous souhaitez appeler une fonction pouvant générer une erreur, vous devez utiliser le mot-clé try dans un bloc do :

do {
  try errorThrower()
}

Pour plus d'informations sur les erreurs Swift: Erreurs

Les méthodes

Les méthodes d'instance sont des fonctions qui appartiennent à des instances d'un type dans Swift (une classe , une structure , une énumération ou un protocole ). Les méthodes de type sont appelées sur un type lui-même.

Méthodes d'instance

Les méthodes d'instance sont définies avec une déclaration func dans la définition du type ou dans une extension .

class Counter {
    var count = 0
    func increment() {
        count += 1
    }
}

La méthode d'instance increment() est appelée sur une instance de la classe Counter :

let counter = Counter()  // create an instance of Counter class   
counter.increment()      // call the instance method on this instance

Type Méthodes

Les méthodes de type sont définies avec les mots-clés static func . (Pour les classes, class func définit une méthode de type pouvant être remplacée par des sous-classes.)

class SomeClass {
    class func someTypeMethod() {
        // type method implementation goes here
    }
}

SomeClass.someTypeMethod()  // type method is called on the SomeClass type itself

Paramètres Inout

Les fonctions peuvent modifier les paramètres qui leur sont transmis si elles sont marquées avec le mot-clé inout . Lors du passage d'un paramètre inout à une fonction, l'appelant doit ajouter un & à la variable transmise.

func updateFruit(fruit: inout Int) {
    fruit -= 1
}

var apples = 30 // Prints "There's 30 apples"
print("There's \(apples) apples")

updateFruit(fruit: &apples)

print("There's now \(apples) apples") // Prints "There's 29 apples".

Cela permet d'appliquer la sémantique de référence aux types qui auraient normalement une sémantique de valeur.

Syntaxe de fermeture de fuite

Lorsque le dernier paramètre d'une fonction est une fermeture

func loadData(id: String, completion:(result: String) -> ()) {
    // ...
    completion(result:"This is the result data")
}

la fonction peut être appelée à l'aide de la syntaxe de fermeture de suivi

loadData("123") { result in
    print(result)
}

Les opérateurs sont des fonctions

Des opérateurs tels que + , - , ?? sont une sorte de fonction nommée en utilisant des symboles plutôt que des lettres. Ils sont appelés différemment des fonctions:

• Préfixe: - x
• Infix: x + y
• Postfix: x ++

Vous pouvez en savoir plus sur les opérateurs de base et les opérateurs avancés dans The Swift Programming Language.

Paramètres Variadic

Parfois, il n'est pas possible de répertorier le nombre de paramètres dont une fonction peut avoir besoin. Considérons une fonction de sum :

func sum(_ a: Int, _ b: Int) -> Int {
    return a + b
}

Cela fonctionne bien pour trouver la somme de deux nombres, mais pour trouver la somme de trois, il faudrait écrire une autre fonction:

func sum(_ a: Int, _ b: Int, _ c: Int) -> Int {
    return a + b + c
}

et un avec quatre paramètres en aurait besoin d'un autre, et ainsi de suite. Swift permet de définir une fonction avec un nombre variable de paramètres en utilisant une séquence de trois périodes: ... Par exemple,

func sum(_ numbers: Int...) -> Int {
    return numbers.reduce(0, combine: +)
}

Remarquez comment le paramètre de numbers , qui est variadique, est fusionné en un seul Array de type [Int] . Cela est vrai en général, les paramètres variadiques de type T... sont accessibles en tant que [T] .

Cette fonction peut maintenant être appelée comme ceci:

let a = sum(1, 2) // a == 3
let b = sum(3, 4, 5, 6, 7) // b == 25

Un paramètre variadique dans Swift ne doit pas nécessairement se trouver à la fin de la liste de paramètres, mais il ne peut y en avoir qu'un dans chaque signature de fonction.

Parfois, il est pratique de mettre une taille minimale sur le nombre de paramètres. Par exemple, cela n'a pas vraiment de sens de prendre la sum de aucune valeur. Un moyen simple d’imposer cela est de mettre des paramètres requis non variadiques, puis d’ajouter le paramètre variadic après. Pour être sûr que cette sum ne peut être appelée qu'avec au moins deux paramètres, nous pouvons écrire

func sum(_ n1: Int, _ n2: Int, _ numbers: Int...) -> Int {
    return numbers.reduce(n1 + n2, combine: +)
}

sum(1, 2) // ok
sum(3, 4, 5, 6, 7) // ok
sum(1) // not ok
sum() // not ok

Des indices

Les classes, les structures et les énumérations peuvent définir des indices, qui sont des raccourcis pour accéder aux éléments membres d'une collection, d'une liste ou d'une séquence.

Exemple

struct DaysOfWeek {
  
  var days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
  
  subscript(index: Int) -> String {
    get {
      return days[index]
    }
    set {
      days[index] = newValue
    }
  }
}

Indice d'utilisation

var week = DaysOfWeek()
//you access an element of an array at index by array[index].
debugPrint(week[1])
debugPrint(week[0])
week[0] = "Sunday"
debugPrint(week[0])

Options des indices:

Les indices peuvent prendre n'importe quel nombre de paramètres d'entrée, et ces paramètres d'entrée peuvent être de tout type. Les indices peuvent également renvoyer n'importe quel type. Les indices peuvent utiliser des paramètres variables et des paramètres variadiques, mais ne peuvent pas utiliser de paramètres d'entrée ou de sortie ni fournir des valeurs de paramètres par défaut.

Exemple:

struct Food {
  
  enum MealTime {
    case Breakfast, Lunch, Dinner
  }
  
  var meals: [MealTime: String] = [:]
  
  subscript (type: MealTime) -> String? {
    get {
      return meals[type]
    }
    set {
      meals[type] = newValue
    }
  }
}

Usage

var diet = Food()
diet[.Breakfast] = "Scrambled Eggs"
diet[.Lunch] = "Rice"

debugPrint("I had \(diet[.Breakfast]) for breakfast")

Fonctions avec fermetures

L'utilisation de fonctions qui intègrent et exécutent des fermetures peut être extrêmement utile pour envoyer un bloc de code à exécuter ailleurs. Nous pouvons commencer par permettre à notre fonction d’accepter une fermeture facultative qui, dans ce cas, renverra Void .

func closedFunc(block: (()->Void)? = nil) {
    print("Just beginning")

    if let block = block {
        block()
    }
}

Maintenant que notre fonction a été définie, appelons-la et transmettons du code:

closedFunc() { Void in
    print("Over already")
}

En utilisant une fermeture finale avec notre appel de fonction, nous pouvons transmettre du code (dans ce cas, print ) pour être exécuté à un moment donné dans notre fonction closedFunc() .

Le journal devrait imprimer:

Que commencer

Déjà sur

Un cas d'utilisation plus spécifique pourrait inclure l'exécution de code entre deux classes:

class ViewController: UIViewController {

    override func viewDidLoad() {
        let _  = A.init(){Void in self.action(2)}
    }

    func action(i: Int) {
        print(i)
    }
}


class A: NSObject {
    var closure : ()?

    init(closure: (()->Void)? = nil) {
        // Notice how this is executed before the  closure
        print("1")
        // Make sure closure isn't nil
        self.closure = closure?()
    }
}

Le journal devrait imprimer:

1

2

Fonctions de passage et de retour

La fonction suivante renvoie une autre fonction en tant que résultat pouvant être affectée ultérieurement à une variable et appelée:

func jediTrainer () -> ((String, Int) -> String) {
  func train(name: String, times: Int) -> (String) {
    return "\(name) has been trained in the Force \(times) times"
  }
  return train
}

let train = jediTrainer()
train("Obi Wan", 3)

Types de fonctions

Chaque fonction a son propre type de fonction, composé des types de paramètres et du type de retour de la fonction elle-même. Par exemple la fonction suivante:

func sum(x: Int, y: Int) -> (result: Int) { return x + y }

a un type de fonction de:

(Int, Int) -> (Int)

Les types de fonction peuvent donc être utilisés comme types de paramètres ou comme types de retour pour les fonctions d'imbrication.