Le Tutoriel de Swift Function

View more categories:

1- Créer un projet

D'abord, pour pratiquer, vous devew créer un projet. Ouvrez  XCode et créez un nouveau Projet:

2- Définition de Function

Dans Swift, une fonction est définie par le "func" mot-clé.  Quand une fonction est nouvellement définie, elle peut prendre une ou plusieurs valeurs comme entrée «paramètres» à la fonction. Il traitera les fonctions dans le corps principal et de transmettre les valeurs de retour des fonctions comme «types de retour» sortie.
La syntaxe définie une fonction:
// Une fonction a un type de retour
func functionName(parameters) -> returntype  
{
   // Statements....
    return value;
}

// La fonction n'a aucun type de retour
func functionName(parameters)
{
    // Statements...
}
C'est une fonction qui se nomme  sayHello, ayant un paramètre du type de  String, et renvoie un  String.
MyFirstFunction.swift
import Foundation

// Définir une fonction (function)
// Nom de la fonction : sayHello
// Paramètre : name, type de chaîne
// Retour (return) : Chaîne
func sayHello(name:String) -> String {
    
    // Si 'name' est vide (empty).
    if name.isEmpty  {
        // Renvoie et termine la fonction.
        return "Hello every body!"
    }
    // Si 'name' n'est pas vide, cet extrait de code sera exécuté.
    return "Hello " + name
    
}

// Définissez une fonction, aucun paramètre, aucun type de retour.
func test_sayHello()  {
    
    // Appelez la fonction sayHello, transmettez une chaîne vide.
    var greeting1 = sayHello("")
    
    
    print("greeting1 = " + greeting1);
    
    // Appelez la fonction sayHello, attribuez la valeur pour le paramètre est "Swift".
    var greeting2 = sayHello("Swift")
    
    print("greeting2 = " + greeting2);
    
}
Editez le fichier source  main.swift  pour tester la fonction que vous venez de créer.
main.swift
import Foundation

// Appelez la fonction test_sayHello()
test_sayHello()
Exécutez l'exemple:

3- Des règles d'appel des fonctions et des méthodes

Swift 2.1 est une règle de nommage des fonctions. Ce sont:
  • Le premier paramètre sur les méthodes et les fonctions ne devrait pas avoir une étiquette (Label) d'argument requise.
  • ​​​​​​​D'autres paramètres aux méthodes et aux fonctions devraient avoir besoin d'étiquettes d'argument.
  • ​​​​​​​Tous les paramètres aux Constructor devraient avoir besoin d'étiquettes (Label) d'argument.
RulesCallFunc.swift
import Foundation

// name1, name2 sont des étiquettes (Label).
func sayHello(name1: String, name2: String)   {
    
    print("Hello " + name1);
    print("Hello " + name2);
    
}



func test_sayHello()    {
    
    
    let tom = "Tom"
    let jerry = "Jerry"
    
    // Les règles d'appel de fonction (Ou de méthode):
    // Le premier paramètre ne requiert pas d'avoir d'étiquette (label) d'argument requises
    // Les autres paramètres doivent avoir des étiquettes d'arguments obligatoires.
    sayHello(tom, name2: jerry)
    
    
}

4- La fonction renvoie une valeur

L'instruction  return arrête l'exécution de la fonction et renvoie une valeur de cette fonction-là.
FunctionExample1.swift
import Foundation

// Définissez une fonction pour additionner le type de numéro Int, renvoyer Int.
func sum(a: Int, b: Int, c: Int) -> Int  {
    
    // Déclarez un type variable de Int
    var ret:Int = a + b + c
    
    return ret
    
}


// Définissez une fonction pour trouver le plus grand nombre en 3 nombres.
func max(a: Int, b: Int, c: Int) -> Int {
    
    // Déclarez la varriable 'm', lui attribuez une value = a.
    var m = a
    
    // Vérifiez si m <b alors attribuez m = b.
    if m < b  {
        m = b
    }
    
    // Si m> c renvoie (return) alors m.
    if m >  c  {
        
        // Terminez la fonction
        return m;
    }
    
    return c
    
}

5- La fonction renvoie multiples valeurs

Dans  Swift, on peut renvoyer plusieurs valeurs ( tuples) dans une fonction. Le t uple est une séquence de valeurs qui est mis dans (), et est séparé par une virgule. Chaque valeur ayant un nom peut l'accéder.
ReturningTupleExample.swift
import Foundation

// Définissez une fonction nommée getMinMax
// L'entrée est un tableau de Int.
// La fonction renvoie deux valeurs :
// Le plus grand nombre et le plus petit nombre dans le tableau.
func getMinMax(arr: [Int]) -> (min: Int, max: Int)   {
    
    // Si le tableau n'a pas d'éléments, renvoyer (0,0).
    if arr.count == 0  {
        // Terminez la fonction
        return (0, 0)
    }
    
    // Déclarez 2 variables 'mi', 'ma'.
    // affecté par le premier élément du tableau.
    var mi: Int = arr[0]
    var ma: Int = arr[0]
    
    
    for a in arr  {
        
        if mi > a  {
            mi = a
        }
        if  ma  <  a  {
            ma = a
        }
    }
    
    return (mi, ma)
}

// Testez la fonction getMinMax.
func test_returningTupleExample()    {
    
    // Un tableau de Int.
    var years: [Int] = [2000, 1989, 1975, 2005, 2016]
    
    // Appelez la fonction getMinMax.
    var y = getMinMax(years)
    
    print("Max = \(y.max)")
    
    print("Min = \(y.min)")
    
    
}
Editez le fichier source  main.swift pour tester l'exemple:
main.swift
import Foundation

test_returningTupleExample()
Exécutez l'exemple:

6- La fonction avec le paramètre Variadic

Swift utilise  "variableName: DataType..." pour déclarer un paramètre  Variadic. Observez l'exemple suivant d'une fonction ayant le paramètre  Variadic et son utilisation.
VariadicParamsFunction.swift
import Foundation

// Une fonction avec le paramètre Variadic: nums
// Le paramètre nums: Comme un tableau de Int.
func sum(nums: Int...) -> Int {
    
    var retNumber : Int = 0
    
    
    for n in nums {
        retNumber = retNumber + n
    }
    
    return retNumber
    
}

// L'utilisation de la fonction, avec le paramètre Variadic:
func test_sum()    {
    
    // Appelez la fonction somme (sum), passez 3 paramètres.
    var sum1 = sum(1, 2, 3)
    
    print("sum(1, 2, 3) = \(sum1)")
    
    // Appelez la fonction sum, passez 4 paramètres.
    var sum2 = sum(1,4, 5, 7)
    
    print("sum(1,4, 5, 7) = \(sum2)")
    
}
Exécutez l'exemple:

7- La fonction à l'intérieur une fonction

En Swift, des paramètres peuvent avoir un nom externes et un nom interneles, mais des paramètres nommés internes ne sont utilisés dans le corps de la fonction / méthode.
NestedFunction.swift
import Foundation

// La fonction renvoie le montant de la taxe à la base du code du pays et le salaire.
func getTaxAmount(countryCode:String, salaryAmount:Int) -> Int  {
    
    // Une fonction sert à calculer le montant de l'impôt aux États-Unis.
    func getUsaTaxAmount( salaryAmount: Int)  -> Int {
        // 15%
        return 15*salaryAmount/100
    }
    
    // Une fonction sert à calculer le montant de l'impôt au Vietnam.
    func getVietnamTaxAmount( salaryAmount:Int)  -> Int {
        // 10%
        return 10 * salaryAmount/100
    }
    
    if countryCode == "US" {
        
        return getUsaTaxAmount(salaryAmount)
        
    } else if countryCode == "VN" {
        
        return getVietnamTaxAmount(salaryAmount)
        
    }
    
    // Autres pays (5%)
    return  5 * salaryAmount / 100
    
}

8- Le type de fonction (Function Type)

Dans  Swift, chaque fonction a un type, observez l'exemple suivant:

func sum(a: Int,  b: Int)  -> Int   {
    return a + b;
}
Le type de fonction est:
(Int,Int) -> (Int)

9- La fonction renvoie une fonction

ReturningFunction.swift
import Foundation

// Une fonction pour calculer le montant de l'impôt aux États-Unis.
// Le type de fonction est: (Int) -> (Int)
func getUsaTaxAmount(salary: Int)  -> Int {
    
    return 15 * salary / 100
}

// Une fonction pour calculer le montant de l'impôt au Vietnam.
// Le type de fonction est: (Int) -> (Int)
func getVietnamTaxAmount(salary: Int) -> Int  {
    
    return 10 * salary / 100
}

// Une fonction par défaut pour calculer le montant de la taxe.
// Le type de fonction est: (Int) -> (Int)
func getDefaultTaxAmount(salary: Int) -> Int {
    
    return 5 * salary / 100
}

// Cette fonction renvoie une fonction.
func getTaxFunction(countryCode: String) ->  ( Int -> Int )  {
    
    if countryCode == "US"  {
        return getUsaTaxAmount
        
    } else if countryCode == "VN"  {
        
        return getVietnamTaxAmount
    }
    return getDefaultTaxAmount
    
}


// Test
func  test_returningFunction()  {
    
    var countryCode = "US"
    print("Country Code = " + countryCode)
    
    // Get function.
    var taxFunction =  getTaxFunction(countryCode)
    
    
    var salary = 10000
    
    print("Salary = \(salary)")
    
    var taxAmount = taxFunction(salary)
    
    print("Tax Amount = \(taxAmount)")
}
Editez  main.swift pour tester l'exemple:
main.swift
import Foundation
 

test_returningFunction()
Exécutez l'exemple:

View more categories: