Groovy no es java sin puntos y comas - Codemotion Madrid 2014

Groovy Goodness
PABLO ALBA CHAO
#708090
Porque Groovy no es Java sin puntos y comas

Ego-slide
Pablo Alba
CTO en Kaleidos Open Source
http://kaleidos.net/708090/
http://albaontech.wordpress.com
@_pabloalba_

Corrían los 90...
BufferedReader br = new BufferedReader( new FileReader(" file.txt"));
try {
StringBuilder sb = new StringBuilder();
String line = br.readLine();
while (line != null) {
sb.append(line);
sb.append(System.lineSeparator());
line = br.readLine();
}
String everything = sb.toString();
} finally {
br.close();
}

Corrían los 90...
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
public class Main {
public static void main(String[] args) {
try {
URL google = new URL("http://www.google.com/");
BufferedReader in = new BufferedReader(newInputStreamReader(google.openStream()));
String inputLine;
while ((inputLine = in.readLine()) != null)
System.out.println(inputLine);
}
in.close();
} catch (MalformedURLException me) {
System.out.println(me);
} catch (IOException ioe) {
System.out.println(ioe);
}
}//end main
}

Groovy
¿Qué sabe mucha gente sobre
Groovy?
● Los archivos llevan extensión .groovy
● No lleva punto y coma al final
● Es casi al 100% compatible con código java

Groovy
<<a flat learning curve for Java
developers>>
Guillaume Laforge

Groovy
BufferedReader br = new BufferedReader( new FileReader(" file.txt"));
try {
StringBuilder sb = new StringBuilder() ;
String line = br.readLine() ;
sb.append(line) ;
sb.append(System.lineSeparator()) ;
line = br.readLine() ;
}
String everything = sb.toString() ;
} finally {
br.close() ;
}

Groovy
BufferedReader br = new BufferedReader(new FileReader(" file.txt"))
try {
StringBuilder sb = new StringBuilder()
String line = br.readLine()
sb.append(line)
sb.append(System.lineSeparator())
line = br.readLine()
}
String everything = sb.toString()
} finally {
br.close()
}

Groovy
Groovy goodness...
File file = new File("file.txt"))
String everything = file.text

Groovy
Groovy goodness...
URL url = " http://google.com ".toURL()
print url.text

Groovy
Disclaimer
● No quiero trollear a Java
● Java 8 ha dado un paso de gigante
● Pero Groovy mola más ;)
● Espero que todo el mundo aprenda algo

Groovy
Groovy Goodness: El libro
Hubert A. Klein Ikkink (MrHaki)
http://www.mrhaki.com/

Básicos y misceláneos de groovy
Episode III

public class Saludador {
private String usuario;
public String getUsuario() {
return usuario;
}
public void setUsuario(usuario) {
this.usuario = usuario;
}
public String saluda(String nombre){
return ("Hola " + nombre + ", yo soy " + usuario);
}
}
Saludador saludador = new Saludador();
saludador.setUsuario("Pablo");
System.out.println(saludador.saluda("Guillaume"));
Puntos y coma
opcionales

private String usuario
return usuario
}
this.usuario = usuario
}
return ("Hola " + nombre + ", yo soy " + usuario)
}
}
Saludador saludador = new Saludador()
saludador.setUsuario("Pablo")
System.out.println(saludador.saluda("Guillaume"))
Paréntesis
opcionales

return usuario
}
Returns
opcionales
}
return "Hola " + nombre + ", yo soy " + usuario
}
}
saludador.setUsuario "Pablo"
System.out.println saludador.saluda("Guillaume")

Public
opcionales
usuario
}
}
"Hola " + nombre + ", yo soy " + usuario
}
}

class Saludador {
String getUsuario() {
usuario
}
void setUsuario(usuario) {
}
String saluda(String nombre){
}
Tipos
opcionales
}

class Saludador {
usuario
}
}
}
}
def saludador = new Atajo Saludador()
para print

Getters y
setters
opcionales
class Saludador {
usuario
}
}
}
}
def saludador = new Saludador()
println saludador.saluda("Guillaume")

class Saludador {
}
Invocación al
setter "mágica"
}

class Saludador {
Constructor por
parámetros con
nombre "mágico"
}
}
saludador.usuario = "Pablo"

class Saludador {
Cadenas
interpoladas
(GStrings)
}
}
def saludador = new Saludador(usuario:"Pablo")

class Saludador {
"Hola $nombre, yo soy $usuario"
}
}
Reformateamos...

class Saludador {
"Hola $nombre, yo soy $usuario"
}
}
private String usuario;
return usuario;
}
this.usuario = usuario;
}
return ("Hola " + nombre + ", yo soy }
}
Saludador saludador = new Saludador();
saludador.setUsuario("Pablo");
System.out.println(saludador.saluda("Guillaume"));

Dinámico
def saluda() {
def a = "hola mundo"
println a
a = 3
print a
}
void despidete() {
Integer a = 3
println a
a = "adios" // Error en tiempo de ejecución
println a
}

Estático. Si quieres.
import groovy.transform.CompileStatic
@CompileStatic
void despidete() {
Integer a = 3
println a
a = "adios" //Error en tiempo de compilación
println a
}

Comparación de cadenas
def a = "hola"
assert "hola" == a

Return opcional
String suma(int a, int b) {
a + b
}
assert suma(2, 3) == 5

Casting automático
String diTuNombre() {
Integer a = 3
}
def a = diTuNombre()
assert a == "3"
assert a.class == String

Casting automático
class User{
String nombre
Integer edad
}
def user1 = new User(nombre:"Pablo", edad:36)
assert user1.class == User
def user2 = [nombre:"Pablo", edad:36] as User
User user3 = [nombre:"Pablo", edad:36]

Método with
class User{
String nombre
Integer edad
}
def user = new User()
user.with {
nombre = "Pablo"
edad = 36
}
def sb = new StringBuilder()
sb.with {
append 'Just another way to add '
append 'strings to the StringBuilder ’
append 'object.'
}

Asignación múltiple / Retorno múltiple
def iAmHere() {
[29.20090, 12.90391]
}
def (coordX, coordY) = iAmHere()
assert coordX == 29.20090
assert coordY == 12.90391

Listas (arrays)
//JAVA
String[] lista = new String[] { "uno", "dos", "tres" };
//GROOVY
def lista = ['uno', 'dos', 'tres']
// Las listas tienen length, igual que los arrays
assert 3 == lista.length
// Además tienen size
assert 3 == lista.size()

Mapas
//JAVA
Map <String, String> mapa = new HashMap<String, String>();
mapa.put("nombre", "Pablo");
mapa.put("apellido", "Alba");
//GROOVY
def mapa = [nombre:"Pablo", apellido:"Alba"]

La verdad en Groovy
assert !( null )
assert !( "" )
assert !( [] )
assert !( [:] )
assert !( 0 )
assert new Object()
assert "string"
assert [1, 2, 3]
assert [a:1]
assert 12345

Groovy como lenguaje de scripting
Hola.java
class Hola {
public static void main(String[] args){
System.out.println ("Hola " + args[0]);
}
}
javac Hola.java
java Hola Pablo

Groovy como lenguaje de scripting
meDaIgualElNombre.groovy
println "Hola " + args[0]
groovy meDaIgualElNombre.groovy

Hook de cerrado
addShutdownHook {
println 'Fin del script'
}
println 'Inicio del script'
Thread.sleep 100000

Operadores
Navegación segura
// Modo "JAVA"
if (company != null && company.getAddress() != null
&& company.getAddress().getStreet() != null) {
println company.address.street.name
}
// Modo "Groovy"
println company?.address?.street?.name

Operadores
Operador Elvis
def sampleText
// Operador ternario normal
def ternaryOutput = (sampleText != null) ? sampleText : 'Hello Groovy!'
// Operador Elvis
// Esto se lee: 'Si sampleText no es nulo, asigna sampleText a
// elvisOutput. De otra forma, asigna 'Viva Las Vegas!' a elvisOutput.
def elvisOutput = sampleText ?: 'Viva Las Vegas!'

Operadores
In
// Modo "JAVA"
String[] list = {"a", "b", "c"};
assert Arrays.asList(list).contains("a")
// Modo "GROOVY"
def list = ["a", "b", "c"]
assert "a" in list

Operadores
Multiplicación de String
println '-' * 80
// ----------------------------------------------------------------------------

Strings
Comillas simples
def s1 = 'Esto es una cadena, y podemos usar "comillas dobles"
sin escaparlas’

Strings
Comillas simples triples
def s1 = ‘‘‘Esto es una cadena multilínea
podemos escribir
un montón de líneas
sin preocuparnos de todo
el lío de la concatenación
’’’

Strings
Slashy
def s3 = /Podemos meter casi cualquier cosa en una "string" 'slasy' sin
escaparla. Se usa mucho para expresiones regulares/

Strings
Comillas dobles
def s1 = "Esto es una cadena, y podemos usar ‘comillas simples’
sin escaparlas"

Strings
Comillas dobles triples
def s1 = """Esto es una cadena multilínea
podemos escribir
un montón de líneas
sin preocuparnos de todo
el lío de la concatenación
"""

Strings
GStrings
def nombre = "Pablo"
def s1 = "Hola, $nombre"
assert s1 == "Hola, Pablo"
def edad = 36
def s2 = "Naciste en el año ${2014 - edad}"
assert s2 == "Naciste en el año 1978"

Strings
Invocación de métodos dinámica
Adiós, Reflection!
class Simple {
def hola(nombre) {
"Hola $nombre, ¿cómo estás?"
}
}
def s = new Simple()
def method = 'hola'
assert 'Hola Pablo, ¿cómo estás?' == s."$method"('Pablo')

Strings
¿Es un número?
'42.42'.isNumber()
'42.42'.isDoble()
'42.42'.isFloat()
'42.42'.isInteger()
'42.42'.isLong()

Strings
Substrings
def s = 'Acceder a las cadenas en Groovy es fácil.'
assert 'A' == s.getAt(0)
// Las cadenas funcionan como listas
assert 'A' == s[0]
assert 'Groovy' == s[25..30] // Podemos usar rangos.

Strings
Mayúsculas y minúsculas
assert 'GROOVY' == 'groovy'.toUpperCase()
assert 'groovy' == 'GROOVY'.toLowerCase()
assert 'Groovy' == 'groovy'.capitalize()

Strings
Base64
def s = 'Esto en otros lenguajes es un dolor...'
String encoded = s.bytes.encodeBase64().toString()
assert 'RXN0byBlbiBvdHJvcyBsZW5ndWFqZXMgZXMgdW4gZG9sb3IuLi4=' == encoded
byte[] decoded = encoded.decodeBase64()
assert s == new String(decoded)

Closures
Closure
def sumador = {a, b -> a + b }
assert sumador (3, 4) == 7
assert sumador (‘H’, ‘ola’) == ‘Hola’

Closures
"it"
def doblador = { it * 2}
assert doblador (3) == 6
assert doblador (‘H’) == ‘HH’

Closures
Valores por defecto
def multiplicador = { int a, int b = 10 -> a * b}
assert multiplicador (2, 3) == 6
assert multiplicador (5) == 50
//MissingMethodException
//multiplicador (‘a’)

Closures
Métodos como closures
def logBase10 = Math.&log10
assert logBase10(10) == 1
def printer = System.out.&println
printer "Hola"

Closures
Curry (aplicación parcial)
def restador = {a, b -> a - b }
def invertir = restador.curry(0)
assert invertir(4) == -4
def restaUno = restador.rcurry(1)
assert restaUno(4) == 3

Closures
Memoize
def slow = {n ->
Thread.sleep(1000)
return n
}
slow (1)
slow (1)
slow (1)
slow (1)
slow (1)
// 5.894s

Closures
Memoize
def slow = {n ->
Thread.sleep(1000)
return n
}
def mem = slow.memoize()
mem (1)
mem (1)
mem (1)
mem (1)
mem (1)
// 1.922s

Listas y mapas
Listas: Buscando datos
def patrulla = ['Cíclope', 'Lobezno', 'Tormenta',
'Coloso', 'Rondador']
assert 'Lobezno' == list.find { it == 'Lobezno' }
assert ['Tormenta', 'Rondador'] == list.findAll { it.size() > 7 }
assert 2 == list.findLastIndexOf { it.size() == 7 }

Listas y mapas
Listas: Rangos
def patrulla = ['Cíclope', 'Lobezno', 'Tormenta', 'Coloso', 'Rondador']
assert ['Cíclope', 'Lobezno'] == patrulla[0..1]
assert ['Tormenta', 'Lobezno'] == patrulla[2..1]
assert ['Tormenta', 'Coloso', 'Rondador'] == patrulla[2..-1]

Listas y mapas
Listas: Iteraciones
def patrulla = ['Cíclope', 'Lobezno', 'Tormenta', 'Coloso', 'Rondador']
for (i = 0; i < 5; i++) {
println patrulla[i]
}
5.times{
println patrulla[it]
}
patrulla.each{
println it
}

Listas y mapas
Listas: Features ‘cool’
def list = [2,5,1,9,3,4,2,8,9]
assert list.size() == 9
assert list.sum() == 43
assert list.max() == 9
assert list.min() == 1
assert list.count(9) == 2
assert list.count{ it < 5 } == 5
list.sort()
assert list == [1, 2, 2, 3, 4, 5, 8, 9, 9]
list.unique()
assert list == [1, 2, 3, 4, 5, 8, 9]

Listas y mapas
Listas: Filter / Map / Reduce
class Persona{
String nombre
int edad
}
def personas = [
new Persona(nombre: "Pablo", edad: 36),
new Persona(nombre: "Lucía", edad: 12),
new Persona(nombre: "Isabel", edad: 9)
]
def nombres = personas.findAll { it.edad < 18 }
.collect { it.nombre.toUpperCase() }
.join(', ')
assert nombres == "LUCÍA, ISABEL"

Listas y mapas
Mapas: Buscando datos
def map = [nombre:"Logan", grupo: "Patrulla X"]
def found = map.find { key, value -> key == 'nombre' }
assert found.key == 'nombre'
assert found.value == 'Logan'
found = map.find { it.value =~ /tru/ }
assert found.key == 'grupo'
found.value == 'Patrulla X'

Listas y mapas
Mapas: Features ‘cool’
def m1 = [user: 'palba', age: 36]
def m2 = [user: 'palba', name: 'Pablo']
def m3 = [user: 'carlos', age: 36]
assert m1 - m2 == [age: 36]
assert m1 - m3 == [user: 'palba']
def money = [euro: 166.386, centimo: 1.664, peseta: 1]
assert money.min { it.value }.value == 1
assert money.max { it.value }.key == ‘euro’

¡Gracias!
¡Gracias!
http://kaleidos.net/708090/
http://albaontech.wordpress.com
@_pabloalba_

¿Desea saber más?
http://greachconf.com/
Madrid, April10th & 11th, 2015
http://www.meetup.com/madrid-gug/

Groovy no es java sin puntos y comas - Codemotion Madrid 2014

Más contenido relacionado

Similar a Groovy no es java sin puntos y comas - Codemotion Madrid 2014 (20)

Último (8)

Groovy no es java sin puntos y comas - Codemotion Madrid 2014