[groovy/ca-es] Catalan translation of Groovy (#2742)

* Afegit Go en català

* Go in catalan

* added Kotlin

* kotlin in catalan 80 chars

* Added -ca to the kotlin filename

* Translated Groovy to catalan

* Missed -ca

* Copy & paste problems in the header :-P

ca-es/groovy-ca.html.markdown

@@ -0,0 +1,437 @@
+---
+name: Groovy
+category: language
+language: Groovy
+lang: ca-es
+filename: learngroovy-ca.groovy
+contributors:
+    - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]
+translations:
+    - ["Xavier Sala Pujolar", "http://github.com/utrescu"]
+---
+
+Groovy - Un llenguatge dinàmic per la plataforma Java [Llegir-ne més.](http://www.groovy-lang.org/)
+
+```groovy
+
+/*
+  Posa'l en marxa tu mateix:
+
+  1) Instal.la SDKMAN - http://sdkman.io/
+  2) Instal.la Groovy: sdk install groovy
+  3) Inicia la consola groovy escrivint: groovyConsole
+
+*/
+
+//  Els comentaris d'una sola línia comencen amb dues barres inverses
+/*
+Els comentaris multilínia són com aquest.
+*/
+
+// Hola món
+println "Hola món!"
+
+/*
+  Variables:
+
+  Es poden assignar valors a les variables per fer-los servir més tard
+*/
+
+def x = 1
+println x
+
+x = new java.util.Date()
+println x
+
+x = -3.1499392
+println x
+
+x = false
+println x
+
+x = "Groovy!"
+println x
+
+/*
+  Col.leccions i mapes
+*/
+
+// Crear una llista buida
+def technologies = []
+
+/*** Afegir elements a la llista ***/
+
+// Com en Java
+technologies.add("Grails")
+
+// El shift a l'esquerra afegeix i retorna la llista
+technologies << "Groovy"
+
+// Afegir múltiples elements
+technologies.addAll(["Gradle","Griffon"])
+
+/*** Eliminar elements de la llista ***/
+
+// Com en Java
+technologies.remove("Griffon")
+
+// La resta també funciona
+technologies = technologies - 'Grails'
+
+/*** Iterar per les llistes ***/
+
+// Iterar per tots els elements de la llista
+technologies.each { println "Technology: $it"}
+technologies.eachWithIndex { it, i -> println "$i: $it"}
+
+/*** Comprovar el contingut de la llista ***/
+
+//Comprovar si la llista conté un o més elements (resultat boolea)
+contained = technologies.contains( 'Groovy' )
+
+// O
+contained = 'Groovy' in technologies
+
+// Comprovar diversos elements
+technologies.containsAll(['Groovy','Grails'])
+
+/*** Ordenar llistes ***/
+
+// Ordenar una llista (canvia la original)
+technologies.sort()
+
+// Per ordenar sense canviar la original es pot fer:
+sortedTechnologies = technologies.sort( false )
+
+/*** Manipular llistes ***/
+
+//Canvia tots els elements de la llista
+Collections.replaceAll(technologies, 'Gradle', 'gradle')
+
+// Desordena la llista
+Collections.shuffle(technologies, new Random())
+
+// Buida la llista
+technologies.clear()
+
+// Crear un mapa buit
+def devMap = [:]
+
+// Afegir valors al mapa
+devMap = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+devMap.put('lastName','Perez')
+
+// Iterar per tots els elements del mapa
+devMap.each { println "$it.key: $it.value" }
+devMap.eachWithIndex { it, i -> println "$i: $it"}
+
+// Comprovar si la clau hi és
+assert devMap.containsKey('name')
+
+// Comprova si el mapa conté un valor concret
+assert devMap.containsValue('Roberto')
+
+// Obtenir les claus del mapa
+println devMap.keySet()
+
+// Obtenir els valors del mapa
+println devMap.values()
+
+/*
+  Groovy Beans
+
+  Els GroovyBeans són JavaBeans però amb una sintaxi molt més senzilla
+
+  Quan Groovy es compila a bytecode es fan servir les regles següents.
+
+    * Si el nom és declarat amb un modificador (public, private o protected)
+      es genera el camp
+
+    * Un nom declarat sense modificadors genera un camp privat amb un getter
+      i un setter públics (per exemple una propietat)
+
+    * Si la propietat és declarada final el camp privat es crea i no es
+      genera cap setter.
+
+    * Es pot declarar una propietat i també declarar un getter i un setter.
+
+    * Es pot declarar una propietat i un camp amb el mateix nom, la propietat
+      farà servir el camp.
+
+    * Si es vol una propietat private o protected s'ha de definir el getter i
+      el setter que s'han de declarar private o protected.
+
+    * Si s'accedeix a una propietat de la classe que està definida en temps
+      de compilació amb un this implícit o explícit (per exemple this.foo, o
+      bé només foo), Groovy accedirà al camp directament en comptes de fer-ho
+      a través del getter i el setter.
+
+    * Si s'accedeix a una propietat que no existeix tant implícita com
+      explicitament, llavors Groovy accedirà a la propietat a través de la
+      meta classe, que pot fer que falli en temps d'execució.
+
+*/
+
+class Foo {
+    // Propietat només de lectura
+    final String name = "Roberto"
+
+    // Propietat de només lectura amb getter públic i un setter protected
+    String language
+    protected void setLanguage(String language) { this.language = language }
+
+    // Propietat amb el tipus definit dinàmicament
+    def lastName
+}
+
+/*
+  Bucles i estructres de control
+*/
+
+//Groovy té el format tradicional de if -else
+def x = 3
+
+if(x==1) {
+    println "One"
+} else if(x==2) {
+    println "Two"
+} else {
+    println "X greater than Two"
+}
+
+// Groovy també té l'operador ternari
+def y = 10
+def x = (y > 1) ? "worked" : "failed"
+assert x == "worked"
+
+//I també té 'l'Operador Elvis'!
+//En comptes de fer servir l'operador ternari:
+displayName = user.name ? user.name : 'Anonymous'
+
+// Es pot escriure d'aquesta forma:
+displayName = user.name ?: 'Anonymous'
+
+//Bucle for
+//Itera en un rang
+def x = 0
+for (i in 0 .. 30) {
+    x += i
+}
+
+//Itera per una llista
+x = 0
+for( i in [5,3,2,1] ) {
+    x += i
+}
+
+//Itera per un array
+array = (0..20).toArray()
+x = 0
+for (i in array) {
+    x += i
+}
+
+//Itera per un mapa
+def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+x = 0
+for ( e in map ) {
+    x += e.value
+}
+
+/*
+  Operadors
+
+  Hi ha una llista d'operadors que poden ser sobreescrits en Groovy:
+  http://www.groovy-lang.org/operators.html#Operator-Overloading
+
+  Operadors útils de Groovy
+*/
+//Spread operator:  Invoca una acció en tots els ítems d'un grup d'objectes.
+def technologies = ['Groovy','Grails','Gradle']
+technologies*.toUpperCase() // = a technologies.collect { it?.toUpperCase() }
+
+//Safe navigation operator: fet servir per evitar el NullPointerException.
+def user = User.get(1)
+def username = user?.username
+
+
+/*
+  Closures
+  Un Closure és com un "bloc de codi" o un punter a un mètode. És un troç de
+  codi que està definit i que s podrà executar més tard.
+
+  Més informació a: http://www.groovy-lang.org/closures.html
+*/
+//Exemple:
+def clos = { println "Hola món!" }
+
+println "Executant el Closure:"
+clos()
+
+// Passar paràmetres a un Closure
+def sum = { a, b -> println a+b }
+sum(2,4)
+
+//Els Closures poden fer referència a variables que no formen part de la
+// llista dels seus paràmetres.
+def x = 5
+def multiplyBy = { num -> num * x }
+println multiplyBy(10)
+
+// Si es té un Closure que agafa un element com a argument, se'n pot ignorar
+// la definició
+def clos = { print it }
+clos( "hi" )
+
+/*
+  Groovy pot recordar els resultats dels Closures [1][2][3]
+*/
+def cl = {a, b ->
+    sleep(3000) // simula un procés llarg
+    a + b
+}
+
+mem = cl.memoize()
+
+def callClosure(a, b) {
+    def start = System.currentTimeMillis()
+    mem(a, b)
+    println "(a = $a, b = $b) - en ${System.currentTimeMillis() - start} ms"
+}
+
+callClosure(1, 2)
+callClosure(1, 2)
+callClosure(2, 3)
+callClosure(2, 3)
+callClosure(3, 4)
+callClosure(3, 4)
+callClosure(1, 2)
+callClosure(2, 3)
+callClosure(3, 4)
+
+/*
+  Expando
+
+  La classe Expando és un bean dinàmic al que se li poden afegir propietats i
+  closures com a mètodes d'una instància d'aquesta classe.
+
+http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
+*/
+  def user = new Expando(name:"Roberto")
+  assert 'Roberto' == user.name
+
+  user.lastName = 'Pérez'
+  assert 'Pérez' == user.lastName
+
+  user.showInfo = { out ->
+      out << "Name: $name"
+      out << ", Last name: $lastName"
+  }
+
+  def sw = new StringWriter()
+  println user.showInfo(sw)
+
+
+/*
+  Metaprogrammació (MOP)
+*/
+
+// Fent servir ExpandoMetaClass per afegir comportament
+String.metaClass.testAdd = {
+    println "he afegit això"
+}
+
+String x = "test"
+x?.testAdd()
+
+//Intercepting method calls
+class Test implements GroovyInterceptable {
+    def sum(Integer x, Integer y) { x + y }
+
+    def invokeMethod(String name, args) {
+        System.out.println "Invoca el mètode $name amb arguments: $args"
+    }
+}
+
+def test = new Test()
+test?.sum(2,3)
+test?.multiply(2,3)
+
+//Groovy supporta propertyMissing per gestionar la resolució de propietats
+class Foo {
+   def propertyMissing(String name) { name }
+}
+def f = new Foo()
+
+assertEquals "boo", f.boo
+
+/*
+  TypeChecked i CompileStatic
+  Groovy, by nature, és i sempre serà un llenguatge dinàmic però també té
+  comprovació de tipus i definicions estàtiques
+
+  More info: http://www.infoq.com/articles/new-groovy-20
+*/
+//TypeChecked
+import groovy.transform.TypeChecked
+
+void testMethod() {}
+
+@TypeChecked
+void test() {
+    testMeethod()
+
+    def name = "Roberto"
+
+    println naameee
+
+}
+
+//Un altre exemple:
+import groovy.transform.TypeChecked
+
+@TypeChecked
+Integer test() {
+    Integer num = "1"
+
+    Integer[] numbers = [1,2,3,4]
+
+    Date date = numbers[1]
+
+    return "Test"
+
+}
+
+//exemple de CompileStatic
+import groovy.transform.CompileStatic
+
+@CompileStatic
+int sum(int x, int y) {
+    x + y
+}
+
+assert sum(2,5) == 7
+
+
+```
+
+## Per aprendre'n més
+
+[documentació de Groovy](http://www.groovy-lang.org/documentation.html)
+
+[Cònsola de Groovy](http://groovyconsole.appspot.com/)
+
+Uneix-te a un [grup d'usuaris Groovy]
+(http://www.groovy-lang.org/usergroups.html)
+
+## Llibres
+
+* [Groovy Goodness] (https://leanpub.com/groovy-goodness-notebook)
+
+* [Groovy in Action] (http://manning.com/koenig2/)
+
+* [Programming Groovy 2: Dynamic Productivity for the Java Developer] (http://shop.oreilly.com/product/9781937785307.do)
+
+[1] http://roshandawrani.wordpress.com/2010/10/18/groovy-new-feature-closures-can-now-memorize-their-results/
+[2] http://www.solutionsiq.com/resources/agileiq-blog/bid/72880/Programming-with-Groovy-Trampoline-and-Memoize
+[3] http://mrhaki.blogspot.mx/2011/05/groovy-goodness-cache-closure-results.html