summaryrefslogtreecommitdiffhomepage
path: root/ca-es/kotlin-ca.html.markdown
diff options
context:
space:
mode:
Diffstat (limited to 'ca-es/kotlin-ca.html.markdown')
-rw-r--r--ca-es/kotlin-ca.html.markdown389
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..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/)