Le Tutoriel de Swift Closure

1- Qu'est-ce que Closure?

Closure: Closure est un bloc spécial. Il peut obtenir éventuellement des paramètres et un type de retour.
Il est presque similaire comme un bloque dans C ou Object-C.
Afin de simplifier, vous pouvez observer la déclaration suivante. Pourriez- vous déviner sa signification?
La déclaration dessous peut être décryptée par l'illustration suivante: 
C'est une syntaxe pour déclarer les variables avec le type de données et lui assigner des valeurs avec lesquelles vous êtes familier.
MyFirstClosure.swift
import Foundation

// Declare the variable myVar1, with data type, and assign value.
var myVar1 : () -> () =  {
    
    print("Hello from Closure 1");
}

// Declare the variable myVar2, with data types, and assign value.
var myVar2 : () -> (String)  = { () -> (String) in
    
    return "Hello from Closure 2"
    
}

// Declare the variable myVar3, with data types, and assign value.
var myVar3 : (Int, Int) -> (Int)  =  { (a : Int, b: Int) -> (Int) in
    
    var c : Int =  a + b
    
    return c
}


func test_closure()     {
    
    // Execute Closure.
    myVar1()
    
    // Execute Closure, and get returns value.
    var str2 = myVar2()
    
    print(str2)
    
    // Execute closure, pass parameters
    // and get returns value.
    var c: Int =  myVar3(11, 22)
    
    print(c)
    
}
Closure est un bloque qu'il peut-être comprendre des paramètres et la type de retour.
Syntaxe de Closure:
{  (parameters) -> returntype in
     // statements
}

2- Fonction avec Closure

Function est un cas particulière de Closure. Function est une  Closure nommé ou peut-être dire que la  Closure est une Function anonyme.
Définition:
Usage:

3- La clôture anonyme

Quand déclarer Closure, il n'est pas nécessaire d'écrire le nom des paramètres. Ces paramètres peuvent être références par  $0, $1,...
AnonymousClosure.swift
import Foundation

// Declare a Closure in the usual way.
var myClosure : (String, String) -> String
    
    = { (firstName: String, lastName: String) -> String in
        
        
        return firstName + " " + lastName
}

// Declare a Closure in the anonymous way.
// (Ignore parameter names).
var anonymousClosure : (String, String) -> String
    
    = {
        // Using
        // $0: For first parameter
        // $1: For second parameter.
        return $0 + " " + $1
}
Note: $0, $1,... sont des paramètres anonymes. Ils sont uniquement utilisés dans l'anonymat  Closure. Si vous utilisez le  Closure normal, vous recevrez un message d'erreur:
Anonymous closure arguments cannot be used inside a closure that has explicit arguments
Par exemple, avec l'anonymat  Closure (2):
AnonymosClosure2.swift
import Foundation



func test_anonymousClosure()  {
    
    // Declare a variable type of Closure.
    var mySum : ( Int, Int ) -> (Int)
    
    // Assign a anonymous closure.
    // $0: For first parameter.
    // $1: For second parameter.
    mySum =  {
        return $0 + $1
    }
    
    
    
    var value = mySum(1, 2)
    
    print(value)
    
}

4- Des valeurs de retour implicites

Si dans le contenu de  Closure, il y a une seule expression, vous pouvez omettre le mot- clé return.
ImplicitReturnValues.swift
import Foundation

// This is a closure whose content only has a single expression
var closureWithReturn  =  { (a: Int, b: Int) -> Int in
    
    // A single expression.
    return a + b
    
}

// Can omit the 'return' keyword.
var closureWithoutReturn =  { (a: Int, b: Int) -> Int in
    
    // If only a single expression.
    // Omit 'return' keyword.
    a + b
    
}

5- Clôture dans une fonction

  • TODO

View more categories: