---

1: Introduction aux Closures en Groovy

Les Closures constituent un élément essentiel de la programmation en Groovy, apportant une souplesse et une expressivité accrues dans la manipulation des fonctions. Une Closure peut être considérée comme un bloc de code autonome capable de capturer et de référencer son environnement d'exécution, y compris les variables locales et les paramètres externes. Cette caractéristique unique confère aux Closures une puissance considérable, les transformant en entités dynamiques pouvant être transmises, assignées et invoquées de manière versatile.

En Groovy, les Closures sont omniprésentes, utilisées pour simplifier les tâches courantes telles que le traitement de collections, la gestion d'événements, et bien plus encore. Comprendre les Closures offre aux développeurs un outil puissant pour écrire un code concis et lisible, tout en ouvrant la porte à des paradigmes de programmation plus avancés.

1.1 Comprendre les Closures en Groovy

// Exemple de Closure simple
def myClosure = { println "Ceci est une Closure en Groovy" }
myClosure()

1.2 Structure d'un Closure

// Exemple de Closure avec des paramètres
def add = { a, b -> a + b }
println add(3, 5)  // Résultat: 8

La syntaxe des Closures en Groovy est simple et concise. Une Closure est définie en utilisant les accolades {} et peut contenir des paramètres, des instructions, et éventuellement une valeur de retour. Voici une explication succincte de la syntaxe :

Sans Paramètres :

def maClosure = {
    // Instructions de la Closure
}

Avec Paramètres :

def maClosureAvecParam = { param1, param2 ->
    // Utilisation des paramètres dans la Closure
}

Avec une Valeur de Retour :

def maClosureAvecRetour = { param1, param2 ->
    // Instructions
    return resultat
}

Courte Syntaxe (pour une seule instruction) :

def maClosureCourte = { param -> instruction }

La syntaxe utilise des accolades pour entourer le bloc de code de la Closure et permet une flexibilité dans la définition de paramètres et de valeurs de retour. Les paramètres sont listés entre les parenthèses, et les instructions sont placées à l'intérieur du bloc. La syntaxe concise des Closures en Groovy en fait un outil puissant pour écrire du code clair et expressif.

Module 2: Paramétrisation d'un Closure

2.1 Paramètres d'un Closure

// Exemple de Closure avec des paramètres
def greetClosure = { name -> "Bonjour, $name !" }
println greetClosure("Alice")  // Résultat: Bonjour, Alice !

2.2 Utilisation de la Paramétrisation

// Exemple de Closure avec paramètres optionnels
def greet = { name, greeting = "Bonjour" -> "$greeting, $name !" }
println greet("Bob")  // Résultat: Bonjour, Bob !
println greet("Alice", "Salut")  // Résultat: Salut, Alice !

Module 3: this, delegate et owner

3.1 Le mot-clé this dans un Closure

// Exemple de Closure utilisant this
def closureWithThis = {
    def localVar = 42
    this.getLocalVar()
}

def getLocalVar = {
    println "Accès à localVar depuis un Closure: $localVar"
}

closureWithThis()

3.2 Le concept de Delegate

En Groovy, owner et delegate sont tous deux des concepts liés à la résolution des variables et méthodes dans une closure, mais ils sont utilisés dans des contextes différents.

• Le delegate est un objet auquel une closure délègue l'accès aux variables et méthodes qui ne sont pas définies dans la closure elle-même.
• Il peut être utilisé pour étendre dynamiquement le contexte de la closure en lui fournissant des méthodes ou des propriétés supplémentaires.
• Si la closure fait référence à une variable ou à une méthode qui n'est pas définie dans son propre contexte, elle tentera de résoudre cette référence à partir du delegate.

// Exemple d'utilisation de delegate dans un Closure
class MyClass {
    def greeting = "Bonjour"
}

def myInstance = new MyClass()

def closureWithDelegate = {
    println "Message: $greeting"
}

closureWithDelegate.delegate = myInstance
closureWithDelegate()

3.3 Le mot-clé owner

• L'owner d'une closure est l'objet qui possède la closure. Il est utilisé pour résoudre les variables et les méthodes dans le contexte de la closure.
• Si une closure est définie dans le contexte d'une classe, l'owner sera une instance de cette classe.
• Si une closure est définie en dehors d'une classe, l'owner peut être un objet map ou une autre structure de données.

// Exemple d'utilisation de owner dans un Closure
def closureWithOwner = { println "Propriété de l'owner: $ownerProperty" }

def ownerObject = [ownerProperty: "Valeur de l'owner"]
closureWithOwner.owner = ownerObject
closureWithOwner()

En résumé, owner est l'objet qui possède la closure, tandis que delegate est l'objet utilisé pour résoudre dynamiquement les références de variables et de méthodes dans la closure. L'utilisation de l'un ou de l'autre dépend du contexte spécifique et des besoins de votre application.

Exemples d'utilisation des closures

Les Closures en Groovy sont souvent utilisées dans divers contextes pour simplifier le code et rendre le langage plus expressif. Voici quelques cas d'utilisation courants des Closures avec des exemples de code :

1. Traitement de Collections :

Les Closures sont fréquemment utilisées pour effectuer des opérations sur des collections.

def nombres = [1, 2, 3, 4, 5]

// Exemple d'utilisation de Closure pour le traitement de liste
def carres = nombres.collect { it * it }
println carres  // Affiche [1, 4, 9, 16, 25]

2. Filtrage de Collections :

Les Closures peuvent être utilisées pour filtrer les éléments d'une collection selon des critères spécifiques.

def nombres = [1, 2, 3, 4, 5]

// Exemple d'utilisation de Closure pour filtrer une liste
def pairs = nombres.findAll { it % 2 == 0 }
println pairs  // Affiche [2, 4]

3. Gestion d'Événements :

Les Closures peuvent être employées pour définir des actions à exécuter en réponse à des événements.

// Exemple d'utilisation de Closure pour gérer un événement
def gestionnaireEvenement = {
    println "Événement déclenché !"
}

// Simulation de déclenchement de l'événement
gestionnaireEvenement()

4. Configuration d'Objets :

Les Closures sont souvent utilisées pour configurer des objets de manière concise.

// Exemple d'utilisation de Closure pour configurer un objet
def personne = new Personne().configure {
    nom = "Alice"
    age = 30
}

5. Callbacks :

Les Closures peuvent être utilisées comme des callbacks pour définir des actions à exécuter à un certain point du programme.

// Exemple d'utilisation de Closure comme callback
def effectuerOperation = { operation -> println "Opération: $operation" }

effectuerOperation("Addition")  // Affiche "Opération: Addition"

6. Utilisation dans les Groovy DSL :

Les Closures sont couramment utilisées dans les domain-specific languages (DSL) en Groovy.

// Exemple de DSL simple avec une Closure
def maDSL = {
    propriete1 "Valeur1"
    propriete2 "Valeur2"
}

maDSL()