summaryrefslogtreecommitdiffhomepage
path: root/ca-es
diff options
context:
space:
mode:
Diffstat (limited to 'ca-es')
-rw-r--r--ca-es/go-ca.html.markdown464
-rw-r--r--ca-es/groovy-ca.html.markdown437
-rw-r--r--ca-es/kotlin-ca.html.markdown389
3 files changed, 1290 insertions, 0 deletions
diff --git a/ca-es/go-ca.html.markdown b/ca-es/go-ca.html.markdown
new file mode 100644
index 00000000..99f0d393
--- /dev/null
+++ b/ca-es/go-ca.html.markdown
@@ -0,0 +1,464 @@
+---
+name: Go
+category: language
+language: Go
+lang: ca-es
+filename: learngo-ca.go
+contributors:
+ - ["Sonia Keys", "https://github.com/soniakeys"]
+ - ["Christopher Bess", "https://github.com/cbess"]
+ - ["Jesse Johnson", "https://github.com/holocronweaver"]
+ - ["Quint Guvernator", "https://github.com/qguv"]
+ - ["Jose Donizetti", "https://github.com/josedonizetti"]
+ - ["Alexej Friesen", "https://github.com/heyalexej"]
+ - ["Clayton Walker", "https://github.com/cwalk"]
+ - ["Leonid Shevtsov", "https://github.com/leonid-shevtsov"]
+translators:
+ - ["Xavier Sala", "http://github.com/utrescu"]
+---
+
+Go es va crear degut a la necessitat de fer la feina ràpidament. No segueix
+la darrera tendència en informàtica, però és la nova forma i la més ràpida de
+resoldre problemes reals.
+
+Té conceptes familiars de llenguatges imperatius amb tipat estàtic. És ràpid
+compilant i ràpid al executar, afegeix una forma fàcil d'entedre de
+concurrència per CPUs de diferents núclis i té característiques que ajuden en
+la programació a gran escala.
+
+Go té una gran llibreria de funcions estàndard i una comunitat d'usuaris
+entusiasta.
+
+```go
+// Comentari d'una sola línia
+/* Comentari
+multilínia */
+
+// La clausula `package` apareix sempre a sobre de cada fitxer de codi font.
+// Quan es desenvolupa un executable en comptes d'una llibreria el nom que
+// s'ha de fer servir de `package` ha de ser 'main'.
+package main
+
+// `import` es fa servir per indicar quins paquets de llibreries fa servir
+// aquest fitxer.
+import (
+ "fmt" // Un paquet de la llibreria estàndard de Go.
+ "io/ioutil" // Les funcions ioutil de io
+ m "math" // La llibreria de matemàtiques que es referenciarà com a m.
+ "net/http" // Si, un servidor web!
+ "os" // funcions per treballar amb el sistema de fitxers
+ "strconv" // Conversions de cadenes
+)
+
+// La definició d'una funció. `main` és especial. És el punt d'entrada per
+// l'executable. Tant si t'agrada com si no, Go fa servir corxets.
+func main() {
+ // Println imprimeix una línia al canal de sortida.
+ // Es qualifica amb el nom del paquet, fmt.
+ fmt.Println("Hola món!")
+
+ // Crida a una altra funció dins d'aquest paquet.
+ mesEnllaDeHola()
+}
+
+// Els paràmetres de les funcions es posen dins de parèntesis.
+// Els parèntesis fan falta encara que no hi hagi cap paràmetre.
+func mesEnllaDeHola() {
+ var x int // Declaració d'una variable.
+ // S'han de declarar abans de fer-les servir.
+ x = 3 // Assignació d'una variable
+ // Hi ha una forma "Curta" amb :=
+ // Descobreix el tipus, declara la variable i li assigna valor.
+ y := 4
+ sum, prod := learnMultiple(x, y) // La funció retorna dos valors.
+ fmt.Println("sum:", sum, "prod:", prod) // Sortida simple.
+ aprenTipus() // < y minuts, aprèn més!
+}
+
+/* <- comentari multilínia
+Les funcions poden tenir paràmetres i (multiples!) valors de retorn.
+Aquí `x`, `y` són els argumens i `sum` i `prod` són els valors retornats.
+Fixa't que `x` i `sum` reben el tipus `int`.
+*/
+func learnMultiple(x, y int) (sum, prod int) {
+ return x + y, x * y // Retorna dos valors.
+}
+
+// Alguns tipus incorporats i literals.
+func aprenTipus() {
+ // Normalment la declaració curta et dóna el que vols.
+ str := "Learn Go!" // tipus string
+
+ s2 := `Un tipus cadena "normal" pot tenir
+salts de línia.` // El mateix tipus
+
+ // literals Non-ASCII literal. El tipus de Go és UTF-8.
+ g := 'Σ' // El tipus rune, és un àlies de int32 conté un caràcter unicode.
+
+ f := 3.14195 // float64, un número de 64 bits amb coma flotant IEEE-754.
+ c := 3 + 4i // complex128, representat internament amb dos float64.
+
+ // Sintaxi amb var i inicialitzadors.
+ var u uint = 7 // Sense signe, però depèn de la mida com els int.
+ var pi float32 = 22. / 7
+
+ // Conversió de tipus amb declaració curta.
+ n := byte('\n') // byte és un àlies de uint8.
+
+ // Les taules tenen mida fixa en temps de compilació.
+ var a4 [4]int // Taula de 4 enters inicialitzats a zero.
+ a3 := [...]int{3, 1, 5} // Taula inicialitzada amb tres elements
+ // amb els valors 3, 1, i 5.
+
+ // Els "Slices" tenen mida dinàmica. Tant les taules com els "slices"
+ // tenen avantatges però és més habitual que es facin servir slices.
+ s3 := []int{4, 5, 9} // Compara amb a3. Aquí no hi ha els tres punts
+ s4 := make([]int, 4) // Crea un slice de 4 enters inicialitzats a zero.
+ var d2 [][]float64 // Només es declara però no hi ha valors.
+ bs := []byte("a slice") // Sintaxi de conversió de tipus.
+
+ // Com que són dinàmics es poden afegir valors nous als slices.
+ // Per afegir-hi elements es fa servir el mètode append().
+ // El primer argument és l'slice en el que s'afegeix.
+ // Sovint ell mateix com aquí sota.
+ s := []int{1, 2, 3} // Un slice amb tres elements.
+ s = append(s, 4, 5, 6) // Ara s tindrà tres elements més
+ fmt.Println(s) // El resultat serà [1 2 3 4 5 6]
+
+ // Per afegir un slice dins d'un altre en comptes de valors atòmics
+ // S'hi pot passar una referència a l'altre slice o un literal acabat
+ // amb tres punts, que vol dir que s'ha de desempaquetar els elements
+ // i afegir-los a "s"
+ s = append(s, []int{7, 8, 9}...) // El segon argument és un slice
+ fmt.Println(s) // El resultat ara és [1 2 3 4 5 6 7 8 9]
+
+ p, q := aprenMemoria() // Declara p i q com a punters de int.
+ fmt.Println(*p, *q) // * segueix el punter fins a trobar els valors
+
+ // Els "Mapes" són taules dinàmiques associatives com els hash o els
+ // diccionaris d'altres llenguatges.
+ m := map[string]int{"tres": 3, "quatre": 4}
+ m["un"] = 1
+
+ // En Go les variables que no es fan servir generen un error.
+ // El subratllat permet fer servir una variable i descartar-ne el valor.
+ _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
+ // És útil per descartar algun dels valors retornats per una funció
+ // Per exemple, es pot ignorar l'error retornat per os.Create amb la idea
+ // de que sempre es crearà.
+ file, _ := os.Create("output.txt")
+ fmt.Fprint(file, "Així es pot escriure en un fitxer")
+ file.Close()
+
+ // La sortida compta com a ús d'una variable.
+ fmt.Println(s, c, a4, s3, d2, m)
+
+ aprenControlDeFluxe() // Tornem.
+}
+
+// A diferència d'altres llenguatges les funcions poden retornar valors amb
+// nom. Assignant un nom al valor retornat en la declaració de la funció
+// permet retornar valors des de diferents llocs del programa a més de posar
+// el return sense valors
+func aprenRetornAmbNoms(x, y int) (z int) {
+ z = x * y
+ return // el retorn de z és implícit perquè ja té valor
+}
+
+// Go té un recollidor de basura.
+// Té punters però no té aritmetica de punters
+// Es poden cometre errors amb un punter a nil però no incrementant-lo.
+func aprenMemoria() (p, q *int) {
+ // Els valors retornats p i q són punters a un enter.
+ p = new(int) // Funció per reservar memòria
+ // A la memòria ja hi ha un 0 per defecte, no és nil.
+ s := make([]int, 20) // Reserva un bloc de memòria de 20 enters.
+ s[3] = 7 // Assigna un valor a un d'ells.
+ r := -2 // Declare una altra variable local.
+ return &s[3], &r // & agafa l'adreça d'un objecte.
+}
+
+func expensiveComputation() float64 {
+ return m.Exp(10)
+}
+
+func aprenControlDeFluxe() {
+ // Els "If" necessiten corxets però no parèntesis.
+ if true {
+ fmt.Println("ja ho hem vist")
+ }
+ // El format del codi està estandaritzat amb la comanda "go fmt."
+ if false {
+ // Pout.
+ } else {
+ // Gloat.
+ }
+ // Si cal encadenar ifs és millor fer servir switch.
+ x := 42.0
+ switch x {
+ case 0:
+ case 1:
+ case 42:
+ // Els case no "passen a través" no cal "break" per separar-los.
+ /*
+ Per fer-ho hi ha una comanda `fallthrough`, mireu:
+ https://github.com/golang/go/wiki/Switch#fall-through
+ */
+ case 43:
+ // No hi arriba.
+ default:
+ // La opció "default" és opcional
+ }
+ // El 'for' tampoc necessita parèntesis, com el 'if'.
+ // Les variables dins d'un bloc if o for són local del bloc.
+ for x := 0; x < 3; x++ { // ++ is a statement.
+ fmt.Println("iteració", x)
+ }
+ // x == 42.
+
+ // L'única forma de fer bucles en Go és el 'for' però té moltes variants.
+ for { // bucle infinit.
+ break // És una broma!.
+ continue // No hi arriba mai.
+ }
+
+ // Es fa servir "range" per iterar a una taula, un slice, un mapa
+ // o un canal.
+ // range torna un valor (channel) o dos (array, slice, string o map).
+ for key, value := range map[string]int{"un": 1, "dos": 2, "tres": 3} {
+ // Per cada parell del mapa imprimeix la clau i el valor.
+ fmt.Printf("clau=%s, valor=%d\n", key, value)
+ }
+ // Si només cal el valor es pot fer servir _
+ for _, name := range []string{"Robert", "Bill", "Josep"} {
+ fmt.Printf("Hola, %s\n", name)
+ }
+
+ // Es pot usar := per declarar i assignar valors i després
+ // comprovar-lo y > x.
+ if y := expensiveComputation(); y > x {
+ x = y
+ }
+ // Les funcions literals són closures
+ xBig := func() bool {
+ return x > 10000 // Referencia a x declarada sobre el switch.
+ }
+ x = 99999
+ fmt.Println("xBig:", xBig()) // cert
+ x = 1.3e3 // x val 1300
+ fmt.Println("xBig:", xBig()) // fals.
+
+ // A més les funcions poden ser definides i cridades com a arguments per
+ // una funció sempre que:
+ // a) La funció es cridi inmediatament (),
+ // b) El tipus del resultat sigui del tipus esperat de l'argument.
+ fmt.Println("Suma i duplica dos números: ",
+ func(a, b int) int {
+ return (a + b) * 2
+ }(10, 2)) // Es crida amb els arguments 10 i 2
+ // => Suma i duplica dos números: 24
+
+ // Quan el necessitis t'agradarà que hi sigui
+ goto love
+love:
+
+ aprenFabricaDeFuncions() // func que retorna func és divertit(3)(3)
+ aprenDefer() // Revisió ràpida d'una paraula clau.
+ aprendreInterficies() // Bon material properament!
+}
+
+func aprenFabricaDeFuncions() {
+ // Les dues seguents són equivalents, però la segona és més pràctica
+ fmt.Println(sentenceFactory("dia")("Un bonic", "d'estiu!"))
+
+ d := sentenceFactory("dia")
+ fmt.Println(d("Un bonic", "d'estiu!"))
+ fmt.Println(d("Un tranquil", "de primavera!"))
+}
+
+// Els decoradors són habituals en altres llenguatges.
+// Es pot fer el mateix en Go amb funcions literals que accepten arguments.
+func sentenceFactory(mystring string) func(before, after string) string {
+ return func(before, after string) string {
+ return fmt.Sprintf("%s %s %s", before, mystring, after) // nou string
+ }
+}
+
+func aprenDefer() (ok bool) {
+ // Les comandes marcades amb defer s'executen després de que la funció
+ // hagi acabat.
+ defer fmt.Println("Les comandes defer s'executen en ordre invers (LIFO).")
+ defer fmt.Println("\nAquesta és la primera línia que s'imprimeix")
+ // Defer es fa servir gairebé sempre per tancar un fitxer, en el moment
+ // en que acaba el mètode.
+ return true
+}
+
+// Defineix Stringer com un tipus interfície amb el mètode String().
+type Stringer interface {
+ String() string
+}
+
+// Defineix una estrutura que conté un parell d'enters, x i y.
+type parell struct {
+ x, y int
+}
+
+// Defineix un mètode de l'estructura parell. Ara parell implementa Stringer.
+func (p parell) String() string { // p és anomenat el "receptor"
+ // Sprintf és una funció del paquet fmt.
+ // Fa referència als camps de p.
+ return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func aprendreInterficies() {
+ // La sintaxi de claus es pot fer servir per inicialitzar un "struct".
+ // Gràcies a := defineix i inicialitza p com un struct 'parell'.
+ p := parell{3, 4}
+ fmt.Println(p.String()) // Es crida al mètode de p.
+ var i Stringer // Declara i de tipus Stringer.
+ i = p // parell implementa Stringer per tant és vàlid.
+ // Es pot cridar el mètode String() igual que abans.
+ fmt.Println(i.String())
+
+ // Les funcions de fmt criden a String() per aconseguir una representació
+ // imprimible d'un objecte.
+ fmt.Println(p) // Treu el mateix d'abans. Println crida el mètode String.
+ fmt.Println(i) // Idèntic resultat
+
+ aprendreParamentesVariables("Aquí", "estem", "aprenent!")
+}
+
+// Les funcions poden tenir paràmetres variables.
+func aprendreParamentesVariables(myStrings ...interface{}) {
+ // Itera per cada un dels valors dels paràmetres
+ // Ignorant l'índex de la seva posició
+ for _, param := range myStrings {
+ fmt.Println("paràmetre:", param)
+ }
+
+ // Passa el valor de múltipes variables com a paràmetre.
+ fmt.Println("parametres:", fmt.Sprintln(myStrings...))
+
+ aprenControlErrors()
+}
+
+func aprenControlErrors() {
+ // ", ok" Es fa servir per saber si hi és o no.
+ m := map[int]string{3: "tres", 4: "quatre"}
+ if x, ok := m[1]; !ok { // ok serà fals perquè 1 no està en el mapa.
+ fmt.Println("no hi és")
+ } else {
+ fmt.Print(x) // x seria el valor, si no estés en el mapa.
+ }
+ // Un valor d'error donarà més informació sobre l'error.
+ if _, err := strconv.Atoi("no-int"); err != nil { // _ descarta el valor
+ // imprimeix 'strconv.ParseInt: intenta convertir "non-int":
+ // syntaxi invalida'
+ fmt.Println(err)
+ }
+ // Es tornarà a les interfícies més tard. Mentrestant,
+ aprenConcurrencia()
+}
+
+// c és un canal (channel), una forma segura de comunicar objectes.
+func inc(i int, c chan int) {
+ c <- i + 1 // <- és l'operador "envia" quan un canal està a l'esquerra.
+}
+
+// Es pot fer servir inc per incrementar un número de forma concurrent.
+func aprenConcurrencia() {
+ // La funció make es pot fer servir per crear slices, mapes i canals.
+ c := make(chan int)
+ // S'inicien tres goroutines.
+ // Els números s'incrementaran de forma concurrent, En paral·lel
+ // si la màquina on s'executa pot fer-ho i està correctament configurada.
+ // Tots tres envien al mateix canal.
+ go inc(0, c) // go és la comanda que inicia una nova goroutine.
+ go inc(10, c)
+ go inc(-805, c)
+ // Llegeix tres resultats del canal i els imprimeix.
+ // No es pot saber en quin ordre arribaran els resultats!
+ fmt.Println(<-c, <-c, <-c) // Canal a la dreta <- és l'operador "rebre"
+
+ cs := make(chan string) // Un altre canal que processa strings.
+ ccs := make(chan chan string) // Un canal de canals string.
+ go func() { c <- 84 }() // Inicia una goroutine i li envia un valor.
+ go func() { cs <- "paraula" }() // El mateix però amb cs.
+ // Select té una sintaxi semblant a switch però amb canals.
+ // Selecciona un cas aleatòriament dels que poden comunicar-se.
+ select {
+ case i := <-c: // El valor rebit pot ser assignat a una variable,
+ fmt.Printf("és un %T", i)
+ case <-cs: // O es pot descartar
+ fmt.Println("és un string")
+ case <-ccs: // Canal buit, no preparat per la comunicació.
+ fmt.Println("no ha passat.")
+ }
+ // Quan arribi aquí s'haurà agafat un valor de c o bé de cs. Una de les
+ // goroutines iniciades haurà acabat i l'altra romandrà bloquejada.
+
+ aprenProgramacioWeb() // Go ho fa. Tu vols fer-ho.
+}
+
+// Una funció del paquet http inicia un servidor web.
+func aprenProgramacioWeb() {
+
+ // El primer paràmetre de ListenAndServe és l'adreça on escoltar
+ // i el segon és una interfície http.Handler.
+ go func() {
+ err := http.ListenAndServe(":8080", pair{})
+ fmt.Println(err) // no s'han d'ignorar els errors
+ }()
+
+ requestServer()
+}
+
+// Es converteix "parell" en un http.Handler només implementant el
+// mètode ServeHTTP.
+func (p parell) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ // Serveix dades en el http.ResponseWriter.
+ w.Write([]byte("Has après Go en Y minuts!"))
+}
+
+func requestServer() {
+ resp, err := http.Get("http://localhost:8080")
+ fmt.Println(err)
+ defer resp.Body.Close()
+ body, err := ioutil.ReadAll(resp.Body)
+ fmt.Printf("\nEl servidor diu: `%s`", string(body))
+}
+```
+
+## Més informació
+
+L'arrel de tot en Go és la web oficial [official Go web site]
+(http://golang.org/). Allà es pot seguir el tutorial, jugar interactivament
+i llegir molt més del que hem vist aquí.En el "tour",
+[the docs](https://golang.org/doc/) conté informació sobre com escriure codi
+net i efectiu en Go, comandes per empaquetar i generar documentació, i
+història de les versions.
+
+És altament recomanable llegir La definició del llenguatge. És fàcil de llegir
+i sorprenentment curta (com la definició del llenguatge en aquests dies).
+
+Es pot jugar amb codi a [Go playground](https://play.golang.org/p/tnWMjr16Mm).
+Prova de fer canvis en el codi i executar-lo des del navegador! Es pot fer
+servir [https://play.golang.org](https://play.golang.org) com a [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) per provar coses i codi
+en el navegador sense haver d'instal·lar Go.
+
+En la llista de lectures pels estudiants de Go hi ha
+[el codi font de la llibreria estàndard](http://golang.org/src/pkg/).
+Ampliament comentada, que demostra el fàcil que és de llegir i entendre els
+programes en Go, l'estil de programació, i les formes de treballar-hi. O es
+pot clicar en un nom de funció en [la documentació](http://golang.org/pkg/)
+i veure'n el codi!
+
+Un altre gran recurs per aprendre Go és
+[Go by example](https://gobyexample.com/).
+
+Go Mobile afegeix suport per plataformes mòbils (Android i iOS). Es poden
+escriure aplicacions mòbils o escriure llibreries de paquets de Go, que es
+poden cridar des de Java (android) i Objective-C (iOS).
+Comproveu la [Go Mobile page](https://github.com/golang/go/wiki/Mobile) per
+més informació.
diff --git a/ca-es/groovy-ca.html.markdown b/ca-es/groovy-ca.html.markdown
new file mode 100644
index 00000000..57674970
--- /dev/null
+++ b/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
diff --git a/ca-es/kotlin-ca.html.markdown b/ca-es/kotlin-ca.html.markdown
new file mode 100644
index 00000000..cd05a808
--- /dev/null
+++ b/ca-es/kotlin-ca.html.markdown
@@ -0,0 +1,389 @@
+---
+language: kotlin
+contributors:
+ - ["S Webber", "https://github.com/s-webber"]
+translators:
+ - ["Xavier Sala", "https://github.com/utrescu"]
+lang: ca-es
+filename: LearnKotlin-ca.kt
+---
+
+Kotlin és un llenguatge estàtic tipat per la JVM, Android i el navegador.
+És interoperable al 100% amb Java.
+[Llegir-ne més aquí.](https://kotlinlang.org/)
+
+```kotlin
+// Els comentaris d'una línia comencen amb //
+/*
+Els comentaris multilínia són com aquest
+*/
+
+// La paraula clau "package" funciona de la mateixa forma que en Java
+
+package com.learnxinyminutes.kotlin
+
+/*
+El punt d'entrada dels programes en Kotlin és una funció anomenada "main".
+La funció rep un array que té els arguments fets servir al executar-lo.
+*/
+fun main(args: Array<String>) {
+ /*
+ La declaració de variables es pot fer tant amb "var" com amb "val".
+ A les declarades amb "val" no se'ls hi pot canviar el valor
+ en canvi a les declarades amb "var" si.
+ */
+ val fooVal = 10 // no es podrà canviar el valor de fooVal
+ var fooVar = 10
+ fooVar = 20 // fooVar si que es pot canviar
+
+ /*
+ Gairebé sempre, Kotlin pot determinar el tipus d'una variable,
+ de manera que no caldrà definir-lo cada vegada.
+ Però es pot definir el tipus d'una variable explícitament d'aquesta forma:
+ */
+ val foo: Int = 7
+
+ /*
+ Els "strings" es poden representar igual que com es fa en Java.
+ Es poden escapar caràcters amb la barra inversa.
+ */
+ val fooString = "Aquí està la meva cadena!"
+ val barString = "Imprimir en dues línies?\nCap problema!"
+ val bazString = "Es poden posar tabuladors?\tI tant!"
+ println(fooString)
+ println(barString)
+ println(bazString)
+
+ /*
+ Es poden definir strings literals envoltant-los amb les triples cometes
+ (""").
+ Dins hi poden haver tant salts de línies com d'altres caràcters.
+ */
+ val fooRawString = """
+fun helloWorld(val name : String) {
+ println("Hola món!")
+}
+"""
+ println(fooRawString)
+
+ /*
+ Els strings poden contenir expressions de plantilla.
+ Les expressions de plantilla comencen amb el símbol ($).
+ */
+ val fooTemplateString = "$fooString té ${fooString.length} caràcters"
+ println(fooTemplateString)
+
+ /*
+ Perquè una variable pugui contenir null ha de ser declarada específicament
+ com a nullable afengint-li ? al seu tipus.
+ Es pot accedir a una variable nulable fent servir l'operador ?.
+ L'operador ?: permet especificar un valor alternatiu en cas de que la
+ variable sigui null.
+ */
+ var fooNullable: String? = "abc"
+ println(fooNullable?.length) // => 3
+ println(fooNullable?.length ?: -1) // => 3
+ fooNullable = null
+ println(fooNullable?.length) // => null
+ println(fooNullable?.length ?: -1) // => -1
+
+ /*
+ Les funcions es declaren amb la paraula "fun".
+ Els arguments s'especifiquen entre corxets després del nom de la funció.
+ Els arguments poden tenir un valor per defecte.
+ El retorn de les funcions, si cal, es posa després de l'argument.
+ */
+ fun hello(name: String = "món"): String {
+ return "Hola, $name!"
+ }
+ println(hello("foo")) // => Hola, foo!
+ println(hello(name = "bar")) // => Hola, bar!
+ println(hello()) // => Hola, món!
+
+ /*
+ Un dels paràmetres d'una funció pot ser marcat amb la paraula clau
+ "vararg" que permet que una funció accepti un número variable
+ d'arguments.
+ */
+ fun varargExample(vararg names: Int) {
+ println("S'han rebut ${names.size} arguments")
+ }
+ varargExample() // => S'han rebut 0 elements
+ varargExample(1) // => S'ha rebut 1 element
+ varargExample(1, 2, 3) // => S'han rebut 3 elements
+
+ /*
+ Quan una funció consisteix en una sola expressió no calen els corxets
+ El cos de la funció es posa rere el símbol =.
+ */
+ fun odd(x: Int): Boolean = x % 2 == 1
+ println(odd(6)) // => false
+ println(odd(7)) // => true
+
+ // Si el tipus retornat es pot determinar no cal especificar-lo.
+ fun even(x: Int) = x % 2 == 0
+ println(even(6)) // => true
+ println(even(7)) // => false
+
+ // Les funcions poden tenir altres funcions com arguments i
+ // fins i tot retornar-ne.
+ fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+ return {n -> !f.invoke(n)}
+ }
+ // Les funcions amb nom es poden especificar quan fan d'arguments amb ::
+ val notOdd = not(::odd)
+ val notEven = not(::even)
+ // Les expressions lambda es poden posar com arguments.
+ val notZero = not {n -> n == 0}
+ /*
+ Si la lambda només té un paràmetre es pot ometre la seva declaració.
+ El seu valor serà "it".
+ */
+ val notPositive = not {it > 0}
+ for (i in 0..4) {
+ println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+ }
+
+ // Les classes es defineixen amb "class".
+ class ExampleClass(val x: Int) {
+ fun memberFunction(y: Int): Int {
+ return x + y
+ }
+
+ infix fun infixMemberFunction(y: Int): Int {
+ return x * y
+ }
+ }
+ /*
+ Per crear una nova instància es crida al constructor.
+ Tingueu en compte que Kotlin no té l'operador "new".
+ */
+ val fooExampleClass = ExampleClass(7)
+ // Els mètodes es poden cridar amb la notació .
+ println(fooExampleClass.memberFunction(4)) // => 11
+ /*
+ Si una funció ha estat marcada amb "infix" es pot cridar amb la
+ notació infix.
+ */
+ println(fooExampleClass infixMemberFunction 4) // => 28
+
+ /*
+ Les classes "data" són classes que només contenen dades.
+ Es creen automàticament els mètodes "hashCode","equals" i "toString"
+ */
+ data class DataClassExample (val x: Int, val y: Int, val z: Int)
+ val fooData = DataClassExample(1, 2, 4)
+ println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+ // Les classes data tenen un mètode "copy".
+ val fooCopy = fooData.copy(y = 100)
+ println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+ // Els objectes es poden desestructurar amb múltiples variables
+ val (a, b, c) = fooCopy
+ println("$a $b $c") // => 1 100 4
+
+ // desestructurat en un bucle "for"
+ for ((a, b, c) in listOf(fooData)) {
+ println("$a $b $c") // => 1 100 4
+ }
+
+ val mapData = mapOf("a" to 1, "b" to 2)
+ // Els mapes també
+ for ((key, value) in mapData) {
+ println("$key -> $value")
+ }
+
+ // La funció "with" és similar a la de JavaScript.
+ data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+ val fooMutableData = MutableDataClassExample(7, 4, 9)
+ with (fooMutableData) {
+ x -= 2
+ y += 2
+ z--
+ }
+ println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+ /*
+ Es pot crear una llista amb la funció "listOf".
+ La llista serà immutable - no s'hi poden afegir o treure elements.
+ */
+ val fooList = listOf("a", "b", "c")
+ println(fooList.size) // => 3
+ println(fooList.first()) // => a
+ println(fooList.last()) // => c
+ // Es pot accedir als elements a partir del seu índex.
+ println(fooList[1]) // => b
+
+ // Es poden crear llistes mutables amb la funció "mutableListOf".
+ val fooMutableList = mutableListOf("a", "b", "c")
+ fooMutableList.add("d")
+ println(fooMutableList.last()) // => d
+ println(fooMutableList.size) // => 4
+
+ // Es poden crear conjunts amb la funció "setOf".
+ val fooSet = setOf("a", "b", "c")
+ println(fooSet.contains("a")) // => true
+ println(fooSet.contains("z")) // => false
+
+ // Es poden crear mapes amb la funció "mapOf".
+ val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+ // S'accedeix als valors del mapa a partir del seu índex.
+ println(fooMap["a"]) // => 8
+
+ /*
+ Les sequències representen col·leccions evaluades quan fan falta.
+ Podem crear una seqüencia amb la funció "generateSequence".
+ */
+ val fooSequence = generateSequence(1, { it + 1 })
+ val x = fooSequence.take(10).toList()
+ println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+ // Per exemple amb aquesta seqüència es creen els números de Fibonacci:
+ fun fibonacciSequence(): Sequence<Long> {
+ var a = 0L
+ var b = 1L
+
+ fun next(): Long {
+ val result = a + b
+ a = b
+ b = result
+ return a
+ }
+
+ return generateSequence(::next)
+ }
+ val y = fibonacciSequence().take(10).toList()
+ println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+ // Kotlin proporciona funcions de primer ordre per treballar amb
+ // col·leccions.
+ val z = (1..9).map {it * 3}
+ .filter {it < 20}
+ .groupBy {it % 2 == 0}
+ .mapKeys {if (it.key) "parell" else "senar"}
+ println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+ // Es pot fer servir el bucle "for" amb qualsevol cosa que proporcioni
+ // un iterador.
+ for (c in "hello") {
+ println(c)
+ }
+
+ // els bucles "while" funcionen com en altres llenguatges.
+ var ctr = 0
+ while (ctr < 5) {
+ println(ctr)
+ ctr++
+ }
+ do {
+ println(ctr)
+ ctr++
+ } while (ctr < 10)
+
+ /*
+ "if" es pot fer servir com una expressió que retorna un valor.
+ Per això no cal l'operador ternari ?: en Kotlin.
+ */
+ val num = 5
+ val message = if (num % 2 == 0) "parell" else "senar"
+ println("$num is $message") // => 5 is odd
+
+ // "when" es pot fer servir com alternativa a les cadenes "if-else if".
+ val i = 10
+ when {
+ i < 7 -> println("primer bloc")
+ fooString.startsWith("hola") -> println("segon bloc")
+ else -> println("bloc else")
+ }
+
+ // "when" es pot fer servir amb un argument.
+ when (i) {
+ 0, 21 -> println("0 o 21")
+ in 1..20 -> println("en el rang 1 a 20")
+ else -> println("cap dels anteriors")
+ }
+
+ // "when" es pot fer servir com una funció que retorna valors.
+ var result = when (i) {
+ 0, 21 -> "0 o 21"
+ in 1..20 -> "en el rang 1 a 20"
+ else -> "cap dels anteriors"
+ }
+ println(result)
+
+ /*
+ Es pot comprovar el tipus d'un objecte fent servir l'operador "is".
+ Si un objecte passa una comprovació es pot fer servir sense posar-hi
+ cap casting.
+ */
+ fun smartCastExample(x: Any) : Boolean {
+ if (x is Boolean) {
+ // x es converteix automàticament a Booleà
+ return x
+ } else if (x is Int) {
+ // x es converteix automàticament a int
+ return x > 0
+ } else if (x is String) {
+ // x es converteix a string automàticament
+ return x.isNotEmpty()
+ } else {
+ return false
+ }
+ }
+ println(smartCastExample("Hola món!")) // => true
+ println(smartCastExample("")) // => false
+ println(smartCastExample(5)) // => true
+ println(smartCastExample(0)) // => false
+ println(smartCastExample(true)) // => true
+
+ // També es pot cridar smarcast en un bloc when
+ fun smartCastWhenExample(x: Any) = when (x) {
+ is Boolean -> x
+ is Int -> x > 0
+ is String -> x.isNotEmpty()
+ else -> false
+ }
+
+ /*
+ Les extensions són una forma d'afegir noves funcionalitats a una classe.
+ És semblant a les extensions de C#.
+ */
+ fun String.remove(c: Char): String {
+ return this.filter {it != c}
+ }
+ println("Hola món!".remove('l')) // => Hoa, món!
+
+ println(EnumExample.A) // => A
+ println(ObjectExample.hello()) // => hola
+}
+
+// Les classes enumerades són semblants a les de Java
+enum class EnumExample {
+ A, B, C
+}
+
+/*
+El paràmetre "object" es pot fer servir per crear objectes singleton.
+No es poden instanciar però es pot fer referència a la seva única instància
+amb el seu nom.
+Són similars als singletons d'Scala.
+*/
+object ObjectExample {
+ fun hello(): String {
+ return "hola"
+ }
+}
+
+fun useObject() {
+ ObjectExample.hello()
+ val someRef: Any = ObjectExample // podem fer servir el nom de l'objecte
+}
+
+```
+
+### Per llegir més
+
+* [tutorials de Kotlin](https://kotlinlang.org/docs/tutorials/)
+* [Provar Kotlin en el navegador](http://try.kotlinlang.org/)
+* [Llista de recursos de Kotlin](http://kotlin.link/)