Aprende Kotlin de manera rápida

Aprende Kotlin de manera rápida y divertida. Si ya conoces Java o lenguajes de programación similares como C#, no tendrás ningún problema para aprender Kotlin. Su sintaxis concisa y amigable te ayudará a desarrollar aplicaciones modernas en tiempo récord.

En esta guía rápida cubrimos los conceptos básicos de programación en Kotlin. Desde la declaración de variables o las estructuras de control hasta las diferentes colecciones que ofrece el lenguaje.

Requisitos

Visual Studio Code

Compilador Kotlin

Hola Mundo en Kotlin

El punto de entrada de toda aplicación programada en Kotlin es la función main.

fun main() {
    println("Hola Mundo")
}

Variables en Kotlin

Las variables se declaran como var, val y const. Reasignables, de sólo lectura y global inmutables respectivamente. El tipo de variable en Kotlin lo deduce el compilador implícitamente, o bien, podemos indicarlo nosotros mismos.

const val WEEK: Int = 7 // variable constante

fun main() {
    var city: String = "Rome" // variable reasignable
    city = "Venice"
    val car: String = "BMW" // variable no reasignable
    // car = "AUDI"  error: val not reassigned
}

Variables con valor nulo

Por defecto las variables en Kotlin no tienen un valor nulo. Si queremos que acepten valores nulos tenemos que añadir el símbolo “?” al tipo. Posteriormente, a la hora de acceder a un objeto con un posible valor nulo tenemos que usar el operador de navegación segura (?).

fun main() {

    var place: String;
    place = null // error: null can not be a value of a non-null type String
    
    // Para aceptar valores nulos se declaran con ?
    var city: String?;
    city = null 

    // Llamar a valores nulos con ?
    println(city?.length) // Output: null
}

Estructuras de control

Las estructuras de control de flujo usan expresiones condicionales que hacen que el programa ejecute uno u otro bloque de código.

if else

Las siguientes estructuras if /else dirigen el flujo del programa por la primera rama que cumpla con la condición indicada.  En estos ejemplos, la expresión contenida dentro de una de las ramas es asignada a las variables “selectedPlace” y “country”.

// if/else expression
 var savings = 1000
  val selectedPlace = if (savings >= 1500) {
      "Mexico"
    } else if (savings in 750..1499) {
      "Italy"
    } else {
      "another place"
    }
  println("Holidays in $selectedPlace") 
  // Output: Holidays in Italy

  val country = if (savings >= 1500) "Mexico" else "my country"
  println("Holidays in $country") 
  // Output: Holidays in my country

when

Aquí when remplaza la estructura switch usada en otros lenguajes de programación. La palabra reservada when comprueba su argumento con las diferentes ramas de manera secuencial, hasta que una cumpla con la condición. En el caso de no cumplirse ninguna condición, se ejecutara el código de la rama else.

val place = "France"
 val continent = when (place) {
     "México", "Brasil" -> "América"
     "Italy", "France" -> "Europe"
     else -> "another destination"
 }
 println("Holidays in $continent.") 
 // Output: Holidays in Europe.

Bucles for y while

En Kotlin (como en la mayoría de lenguajes de programación) tenemos los bucles for y while. Estructuras que ejecutan una o varias instrucciones repetidamente siempre y cuando se cumpla una condición.

for

Diferentes versiones del bloque for.

for (i in 0..2) print(i) // Output: 012
  
for (i in 1 until 10) print(i) // Output: 123456789
  
for (i in 9 downTo 1 step 2) print(i) // Output: 97531

while

El bucle while primero comprueba que una condición sea cierta, en caso afirmativo ejecutará el bloque. Por otro lado, el bucle do/while primero ejecuta el código y luego verifica la condición.

// while, do/while loops
var money = 1000
while (money > 500) {
  print("enjoy ")
  money -= 200
}
// Output: enjoy enjoy enjoy

var n = 5
do {
  print(n--)
} while (n > 0)
// Output: 54321

Colecciones

En Kotlin tenemos 3 colecciones principales: listas, conjuntos y mapas. Cada una de ellas ofrece 2 versiones: colecciones inmutables y colecciones mutables.

listOf

val immutableList = listOf("Cancún", "Aruba", "Jamaica")
var place = immutableList[0]
println("Holidays on $place.")

setOf

val immutableSet = setOf("Cancún", "Aruba", "Jamaica")
place = immutableSet.elementAt(0)
println("Holidays on $place.")

mutableMapOf

val mutableMap = mutableMapOf("Cancún" to 1000, "Aruba" to 1300, "Jamaica" to 2000)
mutableMap.put("London", 1500)
if ("London" in mutableMap) 
    println("Holidays on London. Price: ${mutableMap["London"]}.")