mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-18 12:52:29 +03:00
402 lines
13 KiB
Kotlin
402 lines
13 KiB
Kotlin
---
|
||
language: kotlin
|
||
contributors:
|
||
- ["S Webber", "https://github.com/s-webber"]
|
||
- ["Aitor Escolar", "https://github.com/aiescola"]
|
||
translators:
|
||
- ["Ivan Alburquerque", "https://github.com/AlburIvan"]
|
||
lang: es-es
|
||
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/)
|