Sintaxis común de Groovy

Groovy es un lenguaje de programación flexible basado en la plataforma Java, que combina muchas características poderosas de Python, Ruby y Smalltalk. A continuación se presentan algunas sintaxis comunes de Groovy para ayudarte a comenzar rápidamente.

Declaración de variables

En Groovy, las variables pueden declararse utilizando la palabra clave def, o bien especificando explícitamente el tipo.

// Usando la palabra clave def
def name = "Groovy"

// Especificando el tipo de forma explícita
String greeting = "Hello, ${name}!"

Tipos de datos

Groovy admite varios tipos de datos, incluyendo enteros, flotantes, booleanos y cadenas, entre otros.

def a = 10          // Entero
def b = 10.5        // Flotante
def c = true        // Booleano
def d = "Groovy"    // Cadena

Operaciones lógicas

Groovy soporta operadores lógicos como && (y lógico), || (o lógico) y ! (no lógico).

def a = 10
def b = 20

if (a > 0 && b > 0) {
    println "Ambos números son positivos"
} else if (a > 0 || b > 0) {
    println "Al menos un número es positivo"
} else {
    println "Ambos números son no positivos"
}

Sentencias condicionales

Groovy admite sentencias condicionales if-else y switch.

def number = 10
if (number > 0) {
    println "El número es positivo"
} else {
    println "El número es no positivo"
}

switch (number) {
    case 0:
        println "El número es cero"
        break
    case { it > 0 }:
        println "El número es positivo"
        break
    default:
        println "El número es negativo"
}

Bucles

Groovy soporta bucles for, while y do-while.

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

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

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

Cadenas de texto

Concatenación de cadenas

En Groovy, se puede utilizar el operador + o la sintaxis ${} para concatenar cadenas.

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

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

Cortar cadenas

Se puede usar el método substring para extraer una parte de una cadena.

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

Reemplazar cadenas

El método replace permite sustituir partes de una cadena.

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

Dividir cadenas

El método split permite dividir una cadena en un arreglo.

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

Dividir y obtener valores

El método tokenize divide una cadena en una lista y permite acceder a elementos específicos mediante índices.

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

Limpiar espacios en blanco

El método trim elimina los espacios en blanco al inicio y al final de una cadena.

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

Longitud de una cadena

La propiedad length permite obtener la longitud de una cadena.

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

Contenido dentro de una cadena

El método contains verifica si una cadena contiene otra subcadena.

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

Búsqueda en una cadena

El método indexOf encuentra la posición de una subcadena dentro de una cadena.

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

Comparación de cadenas

Se pueden usar operadores como ==, !=, <, >, <= y >= para comparar cadenas.

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

Escape de caracteres

El carácter \ se utiliza para escapar caracteres especiales; por ejemplo, \n representa un salto de línea.

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

Plantillas de cadenas

Groovy admite la inserción de variables dentro de cadenas mediante la sintaxis ${}.

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

Validación mediante expresiones regulares

Se puede usar el operador ==~ para realizar coincidencias con expresiones regulares.

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

Cadenas multilínea

Se pueden definir cadenas multilínea utilizando tres comillas """ o '''.

def multiLineStr = """
    This is a multi-line
    string in Groovy.
"""
println multiLineStr

Listas

En Groovy, las listas son una estructura de datos muy utilizada y pueden contener elementos de diferentes tipos. A continuación se presentan algunas sintaxis comunes para trabajar con listas en Groovy.

Definir una lista

Se puede definir una lista utilizando corchetes [].

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

Acceder a elementos de una lista

Los elementos de una lista se acceden mediante su índice, que comienza en 0.

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

Modificar elementos de una lista

Se pueden modificar los elementos de una lista mediante su índice.

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

Agregar elementos

Se pueden añadir elementos a una lista utilizando el método add o el operador de desplazamiento a la izquierda <<.

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

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

Eliminar elementos

Se pueden eliminar elementos de una lista utilizando el método remove.

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

Obtener la longitud de una lista

Se puede obtener la longitud de una lista utilizando el método size.

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

Recorrer una lista

Se puede recorrer una lista utilizando un bucle for.

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

También se puede utilizar el método each para recorrer los elementos de una lista.

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

Transformar una lista

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

Filtrar una lista

find

Devuelve el primer elemento que cumple la condición.

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

findAll

Devuelve una nueva lista con todos los elementos que cumplen la condición.

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

Comprobar si una lista coincide con una condición

any

Verifica si al menos un elemento cumple la condición.

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

every

Verifica si todos los elementos cumplen la condición.

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

Cortar una lista

Se puede obtener una parte de una lista utilizando el método subList.

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

Ordenar una lista

Se puede ordenar una lista utilizando el método sort.

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

Invertir una lista

Se puede invertir una lista utilizando el método reverse.

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

Verificar si una lista contiene un elemento

Se puede verificar si una lista contiene un elemento utilizando el método contains.

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

Concatenar dos listas

Se puede concatenar dos listas utilizando el método plus o el operador +.

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

Vaciar una lista

Se puede vaciar una lista utilizando el método clear.

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

Mapas

En Groovy, los mapas son una estructura de datos muy utilizada para almacenar pares clave-valor. A continuación se presentan algunas sintaxis comunes para trabajar con mapas en Groovy.

Definir un mapa

Se puede definir un mapa utilizando corchetes [:] o llaves {}.

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

Acceder a los valores de un mapa

Se puede acceder a los valores de un mapa mediante su clave.

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

Modificar los valores de un mapa

Se pueden modificar los valores de un mapa mediante su clave.

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

Agregar elementos

Se pueden agregar elementos a un mapa utilizando el método put o asignando directamente un valor.

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

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

Eliminar elementos

Se pueden eliminar elementos de un mapa utilizando el método remove.

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


println map  // Salida: [name:Groovy]

Tamaño del mapa

Se puede utilizar el método size para obtener el tamaño del mapa.

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

Iterar sobre el mapa

Se puede usar el método each para recorrer los pares clave-valor del mapa.

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

Comprobar una clave o un valor

Se pueden utilizar los métodos containsKey y containsValue para verificar si el mapa contiene cierta clave o valor.

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

Vaciar el mapa

El método clear permite vaciar el mapa.

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

Combinar mapas

El método putAll permite fusionar todos los elementos de un mapa en otro.

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

Obtener todas las claves o todos los valores

Los métodos keySet y values permiten extraer todas las claves o todos los valores del mapa.

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

Funciones

En Groovy, las funciones se denominan métodos y pueden definirse dentro de una clase o como parte de un script. A continuación se presentan algunas sintaxis comunes para definir y llamar a funciones en Groovy.

Definir una función

Se puede definir una función utilizando la palabra clave def.

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

Llamar a una función

Una vez definida la función, se puede invocar mediante su nombre y los argumentos correspondientes.

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

Función con parámetros por defecto

Es posible establecer valores predeterminados para los parámetros al definir la función.

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

println greet()        // Salida: Hello, World!
println greet("Groovy") // Salida: Hello, Groovy!

Función con múltiples parámetros

Se pueden definir funciones que aceptan varios argumentos.

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

println add(3, 5)  // Salida: 8

Función anónima

Se pueden definir funciones anónimas y asignarlas a variables o pasarlas como argumentos.

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

Función con parámetros variados

Es posible definir funciones que acepten un número variable de argumentos.

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

println sum(1, 2, 3, 4)  // Salida: 10

Función que acepta cierres

Se pueden definir funciones que toman cierres (Closure) como argumentos.

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

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

Función que devuelve múltiples valores

Se pueden definir funciones que devuelven varios valores; estos valores se agrupan en una lista.

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

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

Función recursiva

Es posible definir funciones recursivas, es decir, que se llaman a sí mismas dentro de su propio cuerpo.

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

println factorial(5)  // Salida: 120