mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 09:41:36 +00:00
400 lines
13 KiB
Markdown
400 lines
13 KiB
Markdown
---
|
|
contributors:
|
|
- ["S Webber", "https://github.com/s-webber"]
|
|
- ["Aitor Escolar", "https://github.com/aiescola"]
|
|
translators:
|
|
- ["Ivan Alburquerque", "https://github.com/AlburIvan"]
|
|
filename: LearnKotlin-es.kt
|
|
---
|
|
|
|
Kotlin es un lenguaje estático tipado para la JVM, Android y el navegador. Es
|
|
100% interoperable con Java.
|
|
[Leer mas aqui.](https://kotlinlang.org/)
|
|
|
|
```java
|
|
// Los comentarios de una sóla línea comienzan con //
|
|
|
|
/*
|
|
Los comentarios multilínea lucen así
|
|
*/
|
|
|
|
// La palabra clave "package" funciona de la misma manera que Java.
|
|
|
|
/*
|
|
El punto de entrada para un programa de Kotlin es una función llamada "main".
|
|
A dicha función se le pasa un arreglo que contiene los argumentos de la linea de comando.
|
|
*/
|
|
fun main(args: Array<String>) {
|
|
/*
|
|
La declaración de valores se realiza utilizando tanto "var" como "val".
|
|
Las declaraciones "val" no pueden ser reasignadas, mientras que "var" sí.
|
|
*/
|
|
val fooVal = 10 // más adelante no podremos reasignar fooVal con un valor distinto.
|
|
var fooVar = 10
|
|
fooVar = 20 // fooVar puede ser reasignado
|
|
|
|
/*
|
|
En la mayoría de los casos, Kotlin puede determinar cuál es el tipo de una variable,
|
|
de tal manera que no tenemos que especificarlo explícitamente cada vez.
|
|
Podemos declarar explícitamente el tipo de una variable así:
|
|
*/
|
|
val foo: Int = 7
|
|
|
|
/*
|
|
A diferencia de JavaScript, aunque el tipo se infiera, es tipado, por lo que no se puede cambiar el tipo a posteriori
|
|
*/
|
|
var fooInt = 14 // Se infiere tipo Int
|
|
fooInt = "Cadena" // ERROR en tiempo de compilación: Type mismatch
|
|
|
|
/*
|
|
Las cadenas pueden ser representadas de la misma manera que Java.
|
|
El escape de caracteres se realiza con una barra invertida.
|
|
*/
|
|
val fooString = "Mi Cadena está aquí!";
|
|
val barString = "¿Imprimiendo en una nueva línea?\nNo hay problema!";
|
|
val bazString = "¿Quíeres agregar una tabulación?\tNo hay problema!";
|
|
println(fooString);
|
|
println(barString);
|
|
println(bazString);
|
|
|
|
/*
|
|
Una cadena está delimitada por comillas triple (""").
|
|
Estas cadenas pueden contener saltos de línea y otros caracteres.
|
|
*/
|
|
val fooRawString = """
|
|
fun helloWorld(val name : String) {
|
|
println("Hola, mundo!")
|
|
}
|
|
"""
|
|
println(fooRawString)
|
|
|
|
/*
|
|
Las cadenas pueden contener interpolación de cadenas.
|
|
La interpolación de cadenas comienza con un signo de dólar ($).
|
|
*/
|
|
val fooTemplateString = "$fooString tiene ${fooString.length} caracteres"
|
|
println(fooTemplateString)
|
|
|
|
/*
|
|
Para que una variable pueda aceptar valor nulo se debe especificar
|
|
explícitamente como anulable añadiendole ? a su tipo.
|
|
Podemos acceder a una variable anulable mediante el uso del operador ?.
|
|
Podemos utilizar el operador ?: para especificar un valor alternativo
|
|
a usar si una variable es nula.
|
|
*/
|
|
var fooNullable: String? = "abc"
|
|
println(fooNullable?.length) // => 3
|
|
println(fooNullable?.length ?: -1) // => 3
|
|
fooNullable = null
|
|
println(fooNullable?.length) // => null
|
|
println(fooNullable?.length ?: -1) // => -1
|
|
|
|
/*
|
|
Las funciones pueden ser declaras usando la palabra clave "fun".
|
|
Los argumentos de las funciones son especificados entre corchetes despues del nombre de la función.
|
|
Los argumentos de las funciones pueden tener opcionalmente un valor por defecto.
|
|
El tipo de retorno de las funciones, de ser requerido, es especificado despues del argumento.
|
|
*/
|
|
fun hello(name: String = "mundo") : String {
|
|
return "Hola, $name!"
|
|
}
|
|
println(hello("foo")) // => Hola, foo!
|
|
println(hello(name = "bar")) // => Hola, bar!
|
|
println(hello()) // => Hola, mundo!
|
|
|
|
/*
|
|
Un parametro de la función puede ser marcado con la palabra clave "vararg"
|
|
que permite que una función acepte un numero variable de argumentos.
|
|
*/
|
|
fun varargExample(vararg names: Int) {
|
|
println("Argument tiene ${names.size} elementos")
|
|
}
|
|
varargExample() // => Argument tiene 0 elementos
|
|
varargExample(1) // => Argument tiene 1 elementos
|
|
varargExample(1, 2, 3) // => Argument tiene 3 elementos
|
|
|
|
/*
|
|
Cuando una función consiste de una sola expresión entonces las llaves
|
|
pueden ser omitidas. El cuerpo es especificado despues del símbolo =
|
|
*/
|
|
fun odd(x: Int): Boolean = x % 2 == 1
|
|
println(odd(6)) // => false
|
|
println(odd(7)) // => true
|
|
|
|
// Si el tipo de retorno puede ser inferido entonces no se necesita
|
|
// especificarlo.
|
|
fun even(x: Int) = x % 2 == 0
|
|
println(even(6)) // => true
|
|
println(even(7)) // => false
|
|
|
|
/*
|
|
Kotlin permite el uso de lambdas, o funciones anónimas
|
|
*/
|
|
|
|
// Sin lambda:
|
|
interface MyListener {
|
|
fun onClick(foo: Foo)
|
|
}
|
|
|
|
fun listenSomething(listener: MyListener) {
|
|
listener.onClick(Foo())
|
|
}
|
|
|
|
listenSomething(object: MyListener {
|
|
override fun onClick(foo: Foo) {
|
|
//...
|
|
}
|
|
})
|
|
|
|
// Con lambda:
|
|
fun listenSomethingLambda(listener: (Foo) -> Unit) {
|
|
listener(Foo())
|
|
}
|
|
|
|
listenSomethingLambda {
|
|
//Se recibe foo
|
|
}
|
|
|
|
// el operador typealias permite, entre otras cosas, simplificar las expresiones con lambdas
|
|
typealias MyLambdaListener = (Foo) -> Unit
|
|
fun listenSomethingLambda(listener: MyLambdaListener) {
|
|
listener(Foo())
|
|
}
|
|
|
|
// Las funciones pueden tomar funciones como argumentos y
|
|
// retornar funciones.
|
|
fun not(f: (Int) -> Boolean) : (Int) -> Boolean {
|
|
return {n -> !f.invoke(n)}
|
|
}
|
|
|
|
// Las funciones con nombre pueden ser especificadas como argumentos
|
|
// utilizando el operador ::.
|
|
val notOdd = not(::odd)
|
|
val notEven = not(::even)
|
|
// Las funciones anónimas pueden ser especificadas como argumentos.
|
|
val notZero = not {n -> n == 0}
|
|
/*
|
|
Si una función anónima tiene un solo parametro entonces la declaración
|
|
puede ser omitida (junto con ->). El nombre del único parametro será "it".
|
|
*/
|
|
val notPositive = not {it > 0}
|
|
for (i in 0..4) {
|
|
println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
|
|
}
|
|
|
|
// La palabra clave "class" es usada para declarar clases.
|
|
class ExampleClass(val x: Int) {
|
|
fun memberFunction(y: Int) : Int {
|
|
return x + y
|
|
}
|
|
|
|
infix fun infixMemberFunction(y: Int) : Int {
|
|
return x * y
|
|
}
|
|
}
|
|
/*
|
|
Para crear una nueva instancia llamamos al constructor.
|
|
Nótese que Kotlin no usa la palabra clave "new".
|
|
*/
|
|
val fooExampleClass = ExampleClass(7)
|
|
// Las funciones miembros pueden ser llamadas usando la notación de punto (.)
|
|
println(fooExampleClass.memberFunction(4)) // => 11
|
|
/*
|
|
Si una función ha sido marcada con la palabra clave "infix" entonces
|
|
esta puede ser invocada usando la notación infija.
|
|
*/
|
|
println(fooExampleClass infixMemberFunction 4) // => 28
|
|
|
|
/*
|
|
Las clases "data" son una manera concisa de crear clases que solo contengan datos.
|
|
Los metodos "hashCode"/"equals" y "toString" son generados automáticamente.
|
|
*/
|
|
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)
|
|
|
|
// las clases de datos tienen una función "copy".
|
|
val fooCopy = fooData.copy(y = 100)
|
|
println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
|
|
|
|
// Los objetos pueden ser estructurados en múltiples variables.
|
|
val (a, b, c) = fooCopy
|
|
println("$a $b $c") // => 1 100 4
|
|
|
|
// La función "with" es similar a la expresión de JavaScript "with".
|
|
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)
|
|
|
|
/*
|
|
Podemos crear una lista utilizando la función "listOf".
|
|
La lista será inmutable - los elementos no pueden ser añadidos o eliminados.
|
|
*/
|
|
val fooList = listOf("a", "b", "c")
|
|
println(fooList.size) // => 3
|
|
println(fooList.first()) // => a
|
|
println(fooList.last()) // => c
|
|
// Los elementos de una lista se pueden acceder a través de su índice.
|
|
println(fooList[1]) // => b
|
|
|
|
// Una lista mutable puede ser creada usando la función "mutableListOf".
|
|
val fooMutableList = mutableListOf("a", "b", "c")
|
|
fooMutableList.add("d")
|
|
println(fooMutableList.last()) // => d
|
|
println(fooMutableList.size) // => 4
|
|
|
|
// Podemos crear un set usando la función "setOf".
|
|
val fooSet = setOf("a", "b", "c")
|
|
println(fooSet.contains("a")) // => true
|
|
println(fooSet.contains("z")) // => false
|
|
|
|
// Podemos crear un mapa usando la función "mapOf".
|
|
val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
|
|
// Se puede acceder a los valores del mapa por su llave.
|
|
println(fooMap["a"]) // => 8
|
|
|
|
// Tanto Map como cualquier colección iterable, tienen la función de extensión forEach
|
|
fooMap.forEach {
|
|
println("${it.key} ${it.value}")
|
|
}
|
|
|
|
/*
|
|
Las secuencias representan colecciones evaluadas diferidamente.
|
|
Podemos crear una secuencia con la función "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]
|
|
|
|
// Un ejemplo usando las secuencias para generar los 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 provee funciones de orden superior para trabajar con colecciones.
|
|
val z = (1..9).map {it * 3}
|
|
.filter {it < 20}
|
|
.groupBy {it % 2 == 0}
|
|
.mapKeys {if (it.key) "even" else "odd"}
|
|
println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
|
|
|
|
// Un bucle "for" puede ser usado con cualquier cosa que provea un iterador.
|
|
for (c in "hello") {
|
|
println(c)
|
|
}
|
|
|
|
// El bucle "while" funciona de la misma manera que en los demás lenguajes.
|
|
var ctr = 0
|
|
while (ctr < 5) {
|
|
println(ctr)
|
|
ctr++
|
|
}
|
|
do {
|
|
println(ctr)
|
|
ctr++
|
|
} while (ctr < 10)
|
|
|
|
/*
|
|
"if" puede ser usado como una expresión que retorna un valor.
|
|
Por esta razón el operador ternario ?: no es necesario en Kotlin.
|
|
*/
|
|
val num = 5
|
|
val message = if (num % 2 == 0) "even" else "odd"
|
|
println("$num is $message") // => 5 is odd
|
|
|
|
// "when" puede ser usado como alternativa a cadenas de "if-else if".
|
|
val i = 10
|
|
when {
|
|
i < 7 -> println("primer bloque")
|
|
fooString.startsWith("hello") -> println("segundo bloque")
|
|
else -> println("else bloque")
|
|
}
|
|
|
|
// "when" puede ser usado con argumentos.
|
|
when (i) {
|
|
0, 21 -> println("0 or 21")
|
|
in 1..20 -> println("in the range 1 to 20")
|
|
else -> println("none of the above")
|
|
}
|
|
|
|
// "when" puede ser usado como una función que retorna un valor.
|
|
var result = when (i) {
|
|
0, 21 -> "0 or 21"
|
|
in 1..20 -> "in the range 1 to 20"
|
|
else -> "none of the above"
|
|
}
|
|
println(result)
|
|
|
|
/*
|
|
Podemos analizar si un objeto es de un tipo particular usando el operador "is".
|
|
Si un objeto pasa un chequeo de tipo entonces éste se puede utilizar como
|
|
ese tipo sin convertido de forma explícita.
|
|
*/
|
|
fun smartCastExample(x: Any) : Boolean {
|
|
return when (x) {
|
|
is Boolean -> x // x es automaticamente convertido a Boolean
|
|
is Int -> x > 0 // x es automaticamente convertido a Int
|
|
is String -> x.isNotEmpty() // x es automaticamente convertido a String
|
|
else -> false
|
|
}
|
|
}
|
|
println(smartCastExample("Hola, mundo!")) // => true
|
|
println(smartCastExample("")) // => false
|
|
println(smartCastExample(5)) // => true
|
|
println(smartCastExample(0)) // => false
|
|
println(smartCastExample(true)) // => true
|
|
|
|
/*
|
|
Las extensiones son una manera de añadir nuevas funcionalidades a una clase.
|
|
Estas son similares a la extensión de métodos en C#.
|
|
*/
|
|
fun String.remove(c: Char): String {
|
|
return this.filter {it != c}
|
|
}
|
|
println("Hola, mundo!".remove('l')) // => Hoa, mundo!
|
|
|
|
println(EnumExample.A) // => A
|
|
println(ObjectExample.hello()) // => hola
|
|
}
|
|
|
|
// Las clases "enum" son similares a los tipos "enum" de Java.
|
|
enum class EnumExample {
|
|
A, B, C
|
|
}
|
|
|
|
/*
|
|
La palabra clave "object" se puede utilizar para crear objetos únicos.
|
|
No podemos asignarlo a una variable, pero podemos hacer referencia a ella por su nombre.
|
|
Esto es similar a los objetos únicos de Scala.
|
|
En la mayoría de ocasiones, los objetos únicos se usan como alternativa a los Singleton.
|
|
*/
|
|
object ObjectExample {
|
|
fun hello() : String {
|
|
return "hola"
|
|
}
|
|
}
|
|
```
|
|
|
|
### Lectura Adicional
|
|
|
|
* [Kotlin tutorials (EN)](https://kotlinlang.org/docs/tutorials/)
|
|
* [Try Kotlin in your browser (EN)](http://try.kotlinlang.org/)
|
|
* [A list of Kotlin resources (EN)](http://kotlin.link/)
|