devstory

Le Tutoriel de Swift Function

View more Tutorials:

Suivez-nous sur notre fanpage pour recevoir des notifications chaque fois qu'il y a de nouveaux articles. Facebook

1- 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:

greeting1 = Helloo everybody!
greeting2 = Hello Swift

2- 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)  
}

3- 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 
}

4- La fonction renvoie multiples valeurs

Dans Swift, on peut renvoyer plusieurs valeurs (tuples) dans une fonction. Le tuple 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:

Max = 2016
Min = 1975

5- 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:

sum(1, 2, 3) = 6
sum(1, 4, 5, 7) = 17

6- 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 
}

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

8- 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:

Country Code = US
Salary = 10000
Tax Amount = 1500

View more Tutorials:

Peut-être que vous êtes intéressé

Voici des leçons en ligne à part du site web o7planning que nous recommandons. La liste comprend des leçons en ligne et celles en promo.