Tempo de leitura: menos de 1 minuto
Há algum tempo atrás, escrevi o post Groovy #4: Dicas e Truques e falei de alguns operadores que o Groovy disponibiliza.
No entanto, o Groovy, disponibiliza vários outros operadores que não tive a oportunidade de falar ainda. Neste post, falarei um pouco mais sobre eles.
Operadores Aritiméticos
Os operadores aritméticos com a exceção do operador de exponenciação, nada difere dos operadores aritméticos do Java.
[code language=”groovy” highlight=”6″]
assert 1 + 2 == 3 //adição
assert 4 – 3 == 1 //subtração
assert 3 * 5 == 15 //multiplicação
assert 3 / 2 == 1.5 //divisão
assert 10 % 3 == 1 //resto de divisão (mod)
assert 2 ** 3 == 8 //exponenciação
[/code]
Operadores de Atribuição Aritimética
Todos os operadores aritméticos a cima também estão disponíveis na atribuição, para isso basta adicionar o sinal “=”, vejamos:
[code language=”groovy”]
//adição e atribuição
def a = 4
a += 3
//exponenciação e atribuição
def b = 3
b **= 2
[/code]
Operador Relacional e Lógico
Nada muda de diferente nestes operadores com relação ao Java.
[code language=”groovy”]
// Relacionais
assert 1 + 2 == 3 //igual
assert 3 != 4 //diferente
assert -2 < 3 //menor que
assert 2 <= 3 //menor igual
assert 5 > 1 //maior que
assert 5 >= -2 //maior igual
// lógicos
assert !false // não (not)
assert true && true // e
assert true || false // ou
[/code]
Nota: Só cuidado com a precedência, o lógico “not” precede o lógico “e”. E o lógico “e” tem precedência ao lógico “ou”.
Operadores de Navegação Segura e “Elvis Operator”
Falei deles no post anterior, vale a pena a leitura, pois são operadores muito usados, e dão um bela ajuda ao deixar o código mais “bonito” e legível.
Operadores de ExpressãoRegular
Pattern Operator
O pattern operator disponibiliza uma maneira simples de instancia um objeto do tipo java.util.regex.Pattern, para isso, basta usar o sinal “~”:
[code language=”groovy”]
def p = ~/foo/
assert p instanceof Pattern
// ou
def p = ~’foo’
assert p instanceof Pattern
[/code]
Find e Match Operator
O find é parecido com a pattern , no entanto seu retorno é um objeto do tipo java.util.regex.Matcher, para usa-lo, basta usar o sinal “=~”:
[code language=”groovy”]
def text = "some text to match"
def m = text =~ /\\d/ //não vai "casar", pois na frase não tem numérico, assim lançará exception
assert m instanceof Matcher
if (!m) {
throw new RuntimeException("Oops, number not found!")
}
[/code]
Já o match operator (==~) é um variante do find, só que ao invés de retornar um a java.util.regex.Matcher, retorna um boolean.
[code language=”groovy”]
def text = "some text to match"
def m = text ==~ /\\d/ //não vai "casar", pois na frase não tem numérico, assim lançará exception
assert m instanceof Boolean
if (m) {
throw new RuntimeException("Oops, number not found!")
}
[/code]
Operador de propagação (Spread operator)
No post anterior, falei desse operador que na minha opção é um dos mais legais que o Groovy disponibiliza.
No entanto existe outras formas de uso que vale a pena dizer.
Spreading method arguments
Considere o seguinte método:
[code language=”groovy”]
int function(int x, int y, int z) {
x*y+z
}
// chamando o método
assert function(4,5,6) == 26
[/code]
O jeito formal da chamar o método é passando o paramentos um a um, como feito a cima.
Suponha agora que você tem uma lista com o valores e precisa passar os valores da lista para o método. Para isso basta fazer assim:
[code language=”groovy”]
def args = [4,5,6]
assert function(*args) == 26
[/code]
Prontinho… O resultado obtido é o mesmo do anterior.
Operador Intervalo (Range Operator)
O Groovy suporta intervalos, a notação usada para isso é “..”. Vejamos os exemplos:
[code language=”groovy”]
def range = 0..5
assert (0..5).collect() == [0, 1, 2, 3, 4, 5]
assert (0..<5).collect() == [0, 1, 2, 3, 4]
assert (0..5) instanceof List
assert (0..5).size() == 6
assert (‘a’..’d’).collect() == [‘a’,’b’,’c’,’d’]
[/code]
Operador “Nave espacial” (Spaceship operator)
O nome é engraçado, mas não se assuste, este operador faz miséria. Sua notação é “<=>”, ele tem a mesma função que o método Comparable.compareTo, assim retorna 1, 0 ou -1:
[code language=”groovy”]
assert (1 <=> 1) == 0
assert (1 <=> 2) == -1
assert (2 <=> 1) == 1
assert (‘a’ <=> ‘z’) == -1
[/code]
Membership operator
É um facilitador, funciona com o método List.contains, retornando um boolean. Vejamos:
[code language=”groovy”]
def list = [‘Grace’,’Rob’,’Emmy’]
assert (‘Emmy’ in list)
[/code]
Operador de Coerção (Cast)
Este operador, usamos em substituição ao cast de variáveis, sua notação é “as”. No entanto, ele também funciona como um conversor. No Java ao tentar fazer um cast de Integer para String, será lançado a famigerada ClassCastException, no entanto usando o operador “as”, seus problemas acabam (Seu Creysson agarante). Exemplo:
[code language=”groovy” highlight=”6″]
Integer x = 123
String s = (String) x //ClassCastException
Integer x = 123
String s = x as String
[/code]
Operador de Chamada (Call Operator)
Por fim, temos o operador de chamada, sua notação é “()”. Ele é usado para abreviar uma chamada do método call, nada mais é que uma chamada implícita ao método call de sua classe. Exemplo:
[code language=”groovy”]
class ClasseComMetodoCall {
int call(int x) {
2*x
}
}
def mc = new ClasseComMetodoCall()
assert mc.call(2) == 4 // aqui estamos chamando diretamente o método call
assert mc(2) == 4 // já aqui, estamos chamado o método call implicitamente.
[/code]
É isso aí, o que acharam das maluquices do Groovy
Até a próxima pessoal!
Fonte: Groovy – Operators
