mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-24 10:01:38 +00:00
389 lines
12 KiB
Markdown
389 lines
12 KiB
Markdown
---
|
|
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/)
|