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

Operadores

Siguiente ►
►

En este módulo, aprenderemos sobre los operadores en Groovy. Los operadores son símbolos que le indican al compilador que realice operaciones específicas, como aritméticas, lógicas, de comparación, entre otras. Groovy soporta una amplia gama de operadores que son similares a los de Java, pero también introduce algunos operadores adicionales que facilitan la programación.

Tipos de Operadores

  1. Operadores Aritméticos
  2. Operadores de Asignación
  3. Operadores de Comparación
  4. Operadores Lógicos
  5. Operadores Bit a Bit
  6. Operadores de Incremento y Decremento
  7. Operadores Especiales de Groovy

  1. Operadores Aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas comunes.

Operador Descripción Ejemplo Resultado
+ Suma 5 + 3 8
- Resta 5 - 3 2
* Multiplicación 5 * 3 15
/ División 6 / 3 2
% Módulo 5 % 3 2

Ejemplo Práctico

def a = 10
def b = 3

println "Suma: ${a + b}"        // Suma: 13
println "Resta: ${a - b}"       // Resta: 7
println "Multiplicación: ${a * b}" // Multiplicación: 30
println "División: ${a / b}"    // División: 3.3333333333333335
println "Módulo: ${a % b}"      // Módulo: 1

  1. Operadores de Asignación

Los operadores de asignación se utilizan para asignar valores a las variables.

Operador Descripción Ejemplo Equivalente
= Asignación a = 5 a = 5
+= Suma y asigna a += 3 a = a + 3
-= Resta y asigna a -= 3 a = a - 3
*= Multiplica y asigna a *= 3 a = a * 3
/= Divide y asigna a /= 3 a = a / 3
%= Módulo y asigna a %= 3 a = a % 3

Ejemplo Práctico

def a = 10

a += 5
println "a += 5: ${a}"  // a += 5: 15

a -= 3
println "a -= 3: ${a}"  // a -= 3: 12

a *= 2
println "a *= 2: ${a}"  // a *= 2: 24

a /= 4
println "a /= 4: ${a}"  // a /= 4: 6.0

a %= 5
println "a %= 5: ${a}"  // a %= 5: 1.0

  1. Operadores de Comparación

Los operadores de comparación se utilizan para comparar dos valores.

Operador Descripción Ejemplo Resultado
== Igual a 5 == 3 false
!= No igual a 5 != 3 true
> Mayor que 5 > 3 true
< Menor que 5 < 3 false
>= Mayor o igual que 5 >= 3 true
<= Menor o igual que 5 <= 3 false

Ejemplo Práctico

def a = 10
def b = 5

println "a == b: ${a == b}"  // a == b: false
println "a != b: ${a != b}"  // a != b: true
println "a > b: ${a > b}"    // a > b: true
println "a < b: ${a < b}"    // a < b: false
println "a >= b: ${a >= b}"  // a >= b: true
println "a <= b: ${a <= b}"  // a <= b: false

  1. Operadores Lógicos

Los operadores lógicos se utilizan para combinar múltiples condiciones.

Operador Descripción Ejemplo Resultado
&& AND lógico true && false false
` ` OR lógico
! NOT lógico !true false

Ejemplo Práctico

def a = true
def b = false

println "a && b: ${a && b}"  // a && b: false
println "a || b: ${a || b}"  // a || b: true
println "!a: ${!a}"          // !a: false

  1. Operadores Bit a Bit

Los operadores bit a bit se utilizan para realizar operaciones a nivel de bits.

Operador Descripción Ejemplo Resultado
& AND bit a bit 5 & 3 1
` ` OR bit a bit `5
^ XOR bit a bit 5 ^ 3 6
~ NOT bit a bit ~5 -6
<< Desplazamiento a la izquierda 5 << 1 10
>> Desplazamiento a la derecha 5 >> 1 2
>>> Desplazamiento a la derecha sin signo 5 >>> 1 2

Ejemplo Práctico

def a = 5  // 0101 en binario
def b = 3  // 0011 en binario

println "a & b: ${a & b}"  // a & b: 1 (0001 en binario)
println "a | b: ${a | b}"  // a | b: 7 (0111 en binario)
println "a ^ b: ${a ^ b}"  // a ^ b: 6 (0110 en binario)
println "~a: ${~a}"        // ~a: -6 (complemento a 2 de 0101 es 1010, que es -6 en decimal)
println "a << 1: ${a << 1}" // a << 1: 10 (1010 en binario)
println "a >> 1: ${a >> 1}" // a >> 1: 2 (0010 en binario)
println "a >>> 1: ${a >>> 1}" // a >>> 1: 2 (0010 en binario)

  1. Operadores de Incremento y Decremento

Los operadores de incremento y decremento se utilizan para aumentar o disminuir el valor de una variable en uno.

Operador Descripción Ejemplo Resultado
++ Incremento a++ a = a + 1
-- Decremento a-- a = a - 1

Ejemplo Práctico

def a = 5

println "a++: ${a++}"  // a++: 5 (primero se usa el valor y luego se incrementa)
println "a: ${a}"      // a: 6

println "++a: ${++a}"  // ++a: 7 (primero se incrementa y luego se usa el valor)

println "a--: ${a--}"  // a--: 7 (primero se usa el valor y luego se decrementa)
println "a: ${a}"      // a: 6

println "--a: ${--a}"  // --a: 5 (primero se decrementa y luego se usa el valor)

  1. Operadores Especiales de Groovy

Groovy introduce algunos operadores especiales que no están presentes en Java.

Operador Descripción Ejemplo Resultado
?. Navegación segura a?.b null si a es null
*. Operador de propagación list*.method() Aplica method a cada elemento de list
?.[] Indexación segura map?.['key'] null si map es null
<< Operador de adición list << element Añade element a list

Ejemplo Práctico

def person = null

// Navegación segura
println "Nombre: ${person?.name}"  // Nombre: null

def list = [1, 2, 3]

// Operador de propagación
println "Doble: ${list*.multiply(2)}"  // Doble: [2, 4, 6]

def map = null

// Indexación segura
println "Valor: ${map?.['key']}"  // Valor: null

def elements = [1, 2, 3]

// Operador de adición
elements << 4
println "Elements: ${elements}"  // Elements: [1, 2, 3, 4]

Ejercicios Prácticos

Ejercicio 1: Operaciones Aritméticas

Escribe un script en Groovy que realice las siguientes operaciones y muestre los resultados:

  1. Suma de 15 y 27.
  2. Resta de 45 y 12.
  3. Multiplicación de 7 y 8.
  4. División de 56 entre 7.
  5. Módulo de 29 entre 5.

Solución

def sum = 15 + 27
def difference = 45 - 12
def product = 7 * 8
def quotient = 56 / 7
def remainder = 29 % 5

println "Suma: ${sum}"          // Suma: 42
println "Resta: ${difference}"  // Resta: 33
println "Multiplicación: ${product}" // Multiplicación: 56
println "División: ${quotient}" // División: 8
println "Módulo: ${remainder}"  // Módulo: 4

Ejercicio 2: Comparaciones y Lógica

Escribe un script en Groovy que compare dos números y determine si:

  1. El primer número es mayor que el segundo.
  2. El primer número es igual al segundo.
  3. El primer número es menor o igual al segundo.
  4. Ambos números son positivos.

Solución

def num1 = 10
def num2 = 20

println "num1 > num2: ${num1 > num2}"  // num1 > num2: false
println "num1 == num2: ${num1 == num2}" // num1 == num2: false
println "num1 <= num2: ${num1 <= num2}" // num1 <= num2: true
println "Ambos son positivos: ${num1 > 0 && num2 > 0}" // Ambos son positivos: true

Ejercicio 3: Uso de Operadores Especiales

Escribe un script en Groovy que utilice los operadores especiales ?. y << para:

  1. Navegar de forma segura en un objeto potencialmente nulo.
  2. Añadir elementos a una lista.

Solución

def person = null

// Navegación segura
println "Nombre: ${person?.name}"  // Nombre: null

def elements = [1, 2, 3]

// Operador de adición
elements << 4
println "Elements: ${elements}"  // Elements: [1, 2, 3, 4]

Conclusión

En esta sección, hemos cubierto los operadores en Groovy, incluyendo operadores aritméticos, de asignación, de comparación, lógicos, bit a bit, de incremento y decremento, y operadores especiales de Groovy. Estos operadores son fundamentales para realizar diversas operaciones en tus scripts y programas. Asegúrate de practicar con los ejercicios proporcionados para reforzar tu comprensión de estos conceptos. En el próximo módulo, exploraremos las estructuras de control en Groovy.

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