mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2025-04-26 15:13:56 +00:00
[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
This commit is contained in:
Xavier Sala
ven
parent
bea057020f
commit
8bf95851e1
464
ca-es/go-ca.html.markdown
Normal file
464
ca-es/go-ca.html.markdown
Normal 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
389
ca-es/kotlin-ca.html.markdown
Normal 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/)
|
||||
Loading…
Reference in New Issue
Block a user