Syntaxe courante de Groovy

Groovy est un langage de programmation flexible basé sur la plateforme Java, qui intègre de nombreuses fonctionnalités puissantes issues de Python, Ruby et Smalltalk. Voici quelques syntaxes courantes de Groovy pour vous aider à démarrer rapidement.

Déclaration de variables

En Groovy, les variables peuvent être déclarées avec le mot-clé def ou en spécifiant explicitement leur type.

// Utilisation du mot-clé def
def name = "Groovy"

// Spécification explicite du type
String greeting = "Hello, ${name}!"

Types de données

Groovy prend en charge plusieurs types de données, notamment les entiers, les flottants, les booléens et les chaînes de caractères.

def a = 10          // Entier
def b = 10.5        // Flottant
def c = true        // Booléen
def d = "Groovy"    // Chaîne de caractères

Opérations logiques

Groovy supporte les opérateurs logiques tels que && (ET), || (OU) et ! (NON).

def a = 10
def b = 20

if (a > 0 && b > 0) {
    println "Les deux nombres sont positifs"
} else if (a > 0 || b > 0) {
    println "Au moins un des nombres est positif"
} else {
    println "Les deux nombres sont non positifs"
}

Instructions conditionnelles

Groovy supporte les instructions conditionnelles if-else et switch.

def number = 10
if (number > 0) {
    println "Le nombre est positif"
} else {
    println "Le nombre est non positif"
}

switch (number) {
    case 0:
        println "Le nombre est zéro"
        break
    case { it > 0 }:
        println "Le nombre est positif"
        break
    default:
        println "Le nombre est négatif"
}

Boucles

Groovy propose les boucles for, while et do-while.

// Boucle for
for (i in 0..9) {
    println i
}

// Boucle while
def i = 0
while (i < 10) {
    println i++
}

// Boucle do-while
def j = 0
do {
    println j++
} while (j < 10)

Chaînes de caractères

Concaténation de chaînes

En Groovy, on peut utiliser l’opérateur + ou la syntaxe ${} pour concaténer des chaînes.

def name = "Groovy"
def greeting = "Hello, " + name + "!"
println greeting  // Affiche Hello, Groovy!

def greeting2 = "Hello, ${name}!"
println greeting2  // Affiche Hello, Groovy!

Troncation de chaînes

La méthode substring permet de récupérer une portion d’une chaîne.

def str = "Hello, Groovy!"
println str.substring(7)  // Affiche Groovy !
println str.substring(0, 5)  // Affiche Hello

Remplacement de chaînes

La méthode replace sert à remplacer une partie d’une chaîne.

def str = "Hello, Groovy!"
println str.replace("Groovy", "Java")  // Affiche Hello, Java !

Découpage de chaînes

La méthode split permet de diviser une chaîne en un tableau.

def str = "Hello, Groovy!"
def parts = str.split(", ")
println parts[0]  // Affiche Hello
println parts[1]  // Affiche Groovy !

Extraction par tokenisation

La méthode tokenize sépare une chaîne en une liste et permet d’accéder à des éléments précis via leurs index.

def str = "Hello, Groovy!"
println str.tokenize(",")[1]  // Affiche Groovy !

Suppression des espaces

La méthode trim élimine les espaces au début et à la fin d’une chaîne.

def str = "  Hello, Groovy!  "
println str.trim()  // Affiche Hello, Groovy !

Longueur d’une chaîne

L’attribut length permet d’obtenir la longueur d’une chaîne.

def str = "Hello, Groovy!"
println str.length()  // Affiche 14

Vérification de la présence d’un sous‑string

La méthode contains permet de vérifier si une chaîne contient un sous‑string donné.

def str = "Hello, Groovy!"
println str.contains("Groovy")  // Affiche true

Recherche d’un sous‑string

La méthode indexOf indique la position d’un sous‑string dans une chaîne.

def str = "Hello, Groovy!"
println str.indexOf("Groovy")  // Affiche 7

Comparaison de chaînes

Les opérateurs ==, !=, <, >, <= et >= permettent de comparer des chaînes.

def str1 = "Hello, Groovy!"
def str2 = "Hello, Java!"
println str1 == str2  // Affiche false
println str1 != str2  // Affiche true
println str1 < str2  // Affiche true
println str1 > str2  // Affiche false
println str1 <= str2  // Affiche true
println str1 >= str2  // Affiche false

Échappement de caractères

Le caractère \ sert à échapper certains caractères spéciaux, comme \n pour représenter un saut de ligne.

def str = "Hello,\nGroovy!"
println str  // Affiche Hello,
             // Groovy !

Templates de chaînes

Groovy permet d’intégrer des variables dans une chaîne grâce à la syntaxe ${}.

def name = "Groovy"
def greeting = "Hello, ${name}!"
println greeting  // Affiche Hello, Groovy !

Validation par expression régulière

L’opérateur ==~ permet d’effectuer une validation via une expression régulière.

def emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
def str = "google@163.com"
println str ==~ emailPattern  // Affiche true

Chaînes multi‑lignes

Les chaînes multi‑lignes peuvent être définies en utilisant trois guillemets doubles """ ou triples simples '''.

def multiLineStr = """
    C'est une chaîne multi‑lignes
    en Groovy.
"""
println multiLineStr

Listes (List)

En Groovy, les listes sont une structure de données très utilisée, pouvant contenir des éléments de différents types. Voici quelques syntaxes courantes pour manipuler les listes.

Définition d’une liste

Une liste peut être définie entre crochets [].

def list = [1, 2, 3, 'Groovy', true]

Accès aux éléments d’une liste

Les éléments d’une liste sont accessibles via leur index, commençant à 0.

def list = [1, 2, 3, 'Groovy', true]
println list[3]  // Affiche Groovy

Modification d’un élément

Un élément d’une liste peut être modifié via son index.

def list = [1, 2, 3, 'Groovy', true]
list[3] = 'Java'
println list  // Affiche [1, 2, 3, 'Java', true]

Ajout d’un élément

On peut ajouter un élément à une liste à l’aide de la méthode add ou de l’opérateur de décalage vers la gauche <<.

def list = [1, 2, 3]
list.add(4)
println list  // Affiche [1, 2, 3, 4]

list << 5
println list  // Affiche [1, 2, 3, 4, 5]

Suppression d’un élément

La méthode remove permet de supprimer un élément d’une liste.

def list = [1, 2, 3, 4, 5]
list.remove(0)
println list  // Affiche [2, 3, 4, 5]

Taille d’une liste

La méthode size permet d’obtenir la taille d’une liste.

def list = [1, 2, 3, 4, 5]
println list.size()   // Affiche 5

Parcours d’une liste

On peut parcourir les éléments d’une liste à l’aide d’une boucle for.

def list = [1, 2, 3, 4, 5]
for (item in list) {
    println item
}

On peut également utiliser la méthode each pour parcourir une liste.

def list = [1, 2, 3, 4, 5]
list.each { println it }

Transformation d’une liste

La méthode collect permet de transformer chaque élément d’une liste.

def list = [1, 2, 3, 4, 5]
def newList = list.collect { it * 2 }
println newList  // Affiche [2, 4, 6, 8, 10]

Filtrage d’une liste

find

Retourne le premier élément satisfaisant une condition donnée.

def list = [1, 2, 3, 4, 5]
println list.find { it % 2 == 0 }  // Affiche 2

findAll

Retourne une nouvelle liste contenant tous les éléments répondant à la condition.

def list = [1, 2, 3, 4, 5]
def newList = list.findAll { it % 2 == 0 }
println newList  // Affiche [2, 4]

Vérification d’une condition

any

Vérifie si au moins un élément répond à la condition.

def list = [1, 2, 3, 4, 5]
println list.any { it % 2 == 0 }  // Affiche true

every

Vérifie si tous les éléments répondent à la condition.

def list = [1, 2, 3, 4, 5]
println list.every { it % 2 == 0 }  // Affiche false

Découpage d’une liste

La méthode subList permet d’extraire une portion d’une liste.

def list = [1, 2, 3, 4, 5]
println list.subList(1, 4)  // Affiche [2, 3, 4]

Tri d’une liste

La méthode sort permet de trier une liste.

def list = [3, 1, 4, 2, 5]
println list.sort()  // Affiche [1, 2, 3, 4, 5]

Inversion d’une liste

La méthode reverse permet d’inverser une liste.

def list = [1, 2, 3, 4, 5]
println list.reverse()  // Affiche [5, 4, 3, 2, 1]

Vérification d’une présence

La méthode contains permet de vérifier si une liste contient un élément donné.

def list = [1, 2, 3, 4, 5]
println list.contains(3)  // Affiche true
println list.contains(6)  // Affiche false

Concaténation de listes

La méthode plus ou l’opérateur + permet de joindre deux listes.

def list1 = [1, 2, 3]
def list2 = [4, 5, 6]
println list1.plus(list2)  // Affiche [1, 2, 3, 4, 5, 6]
println list1 + list2      // Affiche [1, 2, 3, 4, 5, 6]

Vidage d’une liste

La méthode clear permet de vider une liste.

def list = [1, 2, 3, 4, 5]
list.clear()
println list  // Affiche []

Cartes (Map)

En Groovy, les cartes (Maps) sont une structure de données très utilisée pour stocker des paires clé‑valeur. Voici quelques syntaxes courantes pour manipuler les cartes.

Définition d’une carte

Une carte peut être définie entre crochets [:] ou entre accolades {}.

def map = [:]
map = ["name": "Groovy", "version": 2.5]

Accès à une valeur

On accède à la valeur associée à une clé via cette dernière.

def map = ["name": "Groovy", "version": 2.5]
println map["name"]  // Affiche Groovy

Modification d’une valeur

On peut modifier la valeur associée à une clé via son index.

def map = ["name": "Groovy", "version": 2.5]
map["name"] = "Java"
println map  // Affiche [name:Java, version:2.5]

Ajout d’une paire clé‑valeur

On peut ajouter une nouvelle paire clé‑valeur à une carte à l’aide de la méthode put ou en assignant directement une valeur.

def map = ["name": "Groovy"]
map.put("version", 2.5)
println map  // Affiche [name:Groovy, version:2.5]

map["author"] = "James"
println map  // Affiche [name:Groovy, version:2.5, author:James]

Suppression d’une paire

La méthode remove permet de supprimer une paire clé‑valeur d’une carte.

def map = ["name": "Groovy", "version": 2.5]
map.remove("version")


println map  // Affiche [name:Groovy]

Taille d’une map

On peut utiliser la méthode size pour obtenir la taille de la map.

def map = ["name": "Groovy", "version": 2.5]
println map.size()  // Affiche 2

Parcourir une map

On peut utiliser la méthode each pour parcourir les paires clé-valeur de la map.

def map = ["name": "Groovy", "version": 2.5]
map.each { key, value ->
    println "${key}: ${value}"
}

Vérifier l’existence d’une clé ou d’une valeur

On peut utiliser les méthodes containsKey et containsValue pour vérifier si une clé ou une valeur est présente dans la map.

def map = ["name": "Groovy", "version": 2.5]
println map.containsKey("name")  // Affiche true
println map.containsValue(2.5)  // Affiche true

Vider une map

On peut utiliser la méthode clear pour vider la map.

def map = ["name": "Groovy", "version": 2.5]
map.clear()
println map  // Affiche [:]

Fusionner des maps

On peut utiliser la méthode putAll pour ajouter tous les éléments d’une map à une autre.

def map1 = ["name": "Groovy"]
def map2 = ["version": 2.5]
map1.putAll(map2)
println map1  // Affiche [name:Groovy, version:2.5]

Obtenir toutes les clés ou toutes les valeurs

On peut utiliser les méthodes keySet et values pour récupérer l’ensemble des clés ou des valeurs de la map.

def map = ["name": "Groovy", "version": 2.5]
println map.keySet()  // Affiche [name, version]
println map.values()  // Affiche [Groovy, 2.5]

Fonctions

En Groovy, les fonctions sont appelées méthodes (Method). Elles peuvent être définies au sein d’une classe ou comme partie d’un script. Voici quelques syntaxes courantes pour définir et appeler des fonctions en Groovy.

Définir une fonction

On peut définir une fonction à l’aide du mot-clé def.

def greet(name) {
    return "Hello, ${name}!"
}

Appeler une fonction

Une fois la fonction définie, on peut l’appeler en passant son nom et ses arguments.

def result = greet("Groovy")
println result  // Affiche Hello, Groovy!

Fonction avec paramètres par défaut

Il est possible de spécifier des valeurs par défaut pour les paramètres lors de la définition d’une fonction.

def greet(name = "World") {
    return "Hello, ${name}!"
}

println greet()        // Affiche Hello, World!
println greet("Groovy") // Affiche Hello, Groovy!

Fonction à plusieurs paramètres

On peut définir une fonction qui accepte plusieurs arguments.

def add(a, b) {
    return a + b
}

println add(3, 5)  // Affiche 8

Fonction anonyme

Il est possible de définir une fonction anonyme et de l’affecter à une variable ou de la passer en argument.

def multiply = { a, b -> a * b }
println multiply(3, 5)  // Affiche 15

Fonction avec arguments variables

On peut définir une fonction qui accepte un nombre variable d’arguments.

def sum(... numbers) {
    def total = 0
    for (number in numbers) {
        total += number
    }
    return total
}

println sum(1, 2, 3, 4)  // Affiche 10

Fonction prenant une closure en argument

On peut définir une fonction qui accepte une closure comme argument.

def operate(a, b, closure) {
    return closure(a, b)
}

def add = { x, y -> x + y }
println operate(3, 5, add)  // Affiche 8

Fonction renvoyant plusieurs valeurs

Il est possible de définir une fonction qui renvoie plusieurs valeurs ; celles-ci seront regroupées dans une liste.

def getCoordinates() {
    return [10, 20]
}

def (x, y) = getCoordinates()
println "x: ${x}, y: ${y}"  // Affiche x: 10, y: 20

Fonction récursive

On peut définir une fonction récursive, c’est-à-dire qui s’appelle elle-même à l’intérieur de sa propre définition.

def factorial(n) {
    if (n <= 1) {
        return 1
    } else {
        return n * factorial(n - 1)
    }
}

println factorial(5)  // Affiche 120