devstory

Le Tutoriel de Swift Function

View more Tutorials:

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

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