info/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2025-08-05 14:27:51 +02:00
Code Issues Releases Wiki Activity

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

Browse Source 
* Afegit Go en català

* Go in catalan

* added Kotlin

* kotlin in catalan 80 chars

* Added -ca to the kotlin filename
This commit is contained in:
Xavier Sala
2017-05-28 17:51:52 +02:00
committed by ven
parent bea057020f
commit 8bf95851e1
2 changed files with 853 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

464
ca-es/go-ca.html.markdown Normal file
View File

@@ -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ó.

389
ca-es/kotlin-ca.html.markdown Normal file
View File

@@ -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/)