El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Closures

Siguiente ►
►

Introducción a las Closures

Las closures en Groovy son una característica poderosa y flexible que permite definir bloques de código que pueden ser asignados a variables, pasados como argumentos a métodos y ejecutados en diferentes contextos. Las closures son similares a las lambdas en otros lenguajes de programación, pero con capacidades adicionales.

Conceptos Clave

  • Definición de Closure: Una closure es un bloque de código que puede ser ejecutado en un contexto diferido.
  • Sintaxis de Closure: Las closures se definen utilizando llaves {} y pueden aceptar parámetros.
  • Contexto de Ejecución: Las closures pueden acceder a variables del contexto en el que fueron definidas.

Sintaxis Básica

La sintaxis básica de una closure en Groovy es la siguiente:

def closureName = { param1, param2 -> 
    // Cuerpo de la closure
    println "Parámetro 1: $param1, Parámetro 2: $param2"
}

Ejemplo Práctico

def greet = { name -> 
    println "Hola, $name!"
}

greet("Mundo")  // Salida: Hola, Mundo!

En este ejemplo, greet es una closure que toma un parámetro name y lo utiliza para imprimir un saludo.

Closures con Diferentes Cantidades de Parámetros

Las closures pueden tener cualquier número de parámetros, incluyendo ninguno.

Sin Parámetros

def sayHello = { 
    println "¡Hola!"
}

sayHello()  // Salida: ¡Hola!

Un Parámetro

def square = { num -> 
    num * num
}

println square(4)  // Salida: 16

Múltiples Parámetros

def add = { a, b -> 
    a + b
}

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

Closures como Argumentos de Métodos

Las closures pueden ser pasadas como argumentos a métodos, lo que permite un alto grado de flexibilidad y reutilización de código.

Ejemplo de Closure como Argumento

def operateOnNumbers = { a, b, operation -> 
    operation(a, b)
}

def multiply = { x, y -> 
    x * y
}

println operateOnNumbers(4, 5, multiply)  // Salida: 20

En este ejemplo, operateOnNumbers es un método que toma dos números y una operación (closure) y aplica la operación a los números.

Closures y el Contexto de Ejecución

Las closures en Groovy pueden acceder a variables definidas en su contexto de creación.

Ejemplo de Contexto de Ejecución

def factor = 2
def multiplyByFactor = { num -> 
    num * factor
}

println multiplyByFactor(5)  // Salida: 10

En este ejemplo, la closure multiplyByFactor accede a la variable factor definida en su contexto de creación.

Ejercicios Prácticos

Ejercicio 1: Crear una Closure para Filtrar una Lista

Crea una closure que filtre una lista de números y devuelva solo los números pares.

def filterEvenNumbers = { list -> 
    list.findAll { it % 2 == 0 }
}

def numbers = [1, 2, 3, 4, 5, 6]
println filterEvenNumbers(numbers)  // Salida: [2, 4, 6]

Ejercicio 2: Crear una Closure para Transformar una Lista

Crea una closure que tome una lista de cadenas y las convierta a mayúsculas.

def toUpperCase = { list -> 
    list.collect { it.toUpperCase() }
}

def words = ["groovy", "is", "cool"]
println toUpperCase(words)  // Salida: [GROOVY, IS, COOL]

Ejercicio 3: Crear una Closure para Calcular el Factorial

Crea una closure que calcule el factorial de un número.

def factorial = { n -> 
    (1..n).inject(1) { acc, val -> acc * val }
}

println factorial(5)  // Salida: 120

Resumen

En esta sección, hemos aprendido sobre las closures en Groovy, su sintaxis básica, cómo pueden aceptar diferentes cantidades de parámetros, y cómo pueden ser utilizadas como argumentos de métodos. También hemos visto cómo las closures pueden acceder a su contexto de ejecución y hemos practicado con algunos ejercicios prácticos. Las closures son una herramienta poderosa en Groovy que permite escribir código más flexible y reutilizable.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados