[go/ca-es] catalan translation of Go (#2741)

* Afegit Go en català

* Go in catalan

* added Kotlin

* kotlin in catalan 80 chars

* Added -ca to the kotlin filename

1 files changed, 389 insertions, 0 deletions

diff --git a/ca-es/kotlin-ca.html.markdown b/ca-es/kotlin-ca.html.markdown
new file mode 100644
index 00000000..5423ef8c
--- /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'han rebut 1 elements
+    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/)