Expresiones frecuentes en Kotlin

Colección de expresiones de uso frecuente (modismos) en Kotlin.

Variables

Intercambiar dos variables:

var a = 1
var b = 2
a = b.also { b = a }

Propiedad lazy:

val p: String by lazy {
    // calcula el valor del string
}

String

Interpolación de Strings:

println("Nombre: $nombre")

Expresiones

Expresión if:

fun foo(param: Int) {
    val result = if (param == 1) {
        "one"
    } else if (param == 2) {
        "two"
    } else {
        "three"
    }
}

Expresión try/catch:

fun test() {
    val result = try {
        count()
    } catch (e: ArithmeticException) {
        throw IllegalStateException(e)
    }

    // trabajando con result
}

Colecciones

Lista de solo lectura:

val list = listOf("a", "b", "c")

Lista mutable:

val lista = listOf("a", "b", "c")
val listaMutable = mutableListOf("a", "b", "c").apply {
    add("d")
    remove("b")
}

Mapa de solo lectura:

val map = mapOf("a" to 1, "b" to 2, "c" to 3)

Mapa mutable:

val mapa = mutableMapOf("a" to 1, "b" to 2, "c" to 3)
mapa["a"] = 10

Acceder a un mapa:

println(map["key"])
map["key"] = value

Filtrar una lista:

val positivos = list.filter { x -> x > 0 }

O, alternativamente y más corto:

val positivos = list.filter { it > 0 }

Comprobar la presencia de un elemento en una colección:

if ("fulano@example.com" in emailsList) { ... }

if ("mengano@example.com" !in emailsList) { ... }

Recorrer un mapa o lista de pares:

for ((k, v) in map) {
    println("$k -> $v")
}

Otra opción:

for (map in mapa) {
    println("${map.key} -> ${map.value}")
}

Rangos

Usar rangos:

for (i in 1..100) { ... }  // incluye 100
for (i in 1 until 100) { ... } // no incluye 100
for (x in 2..10 step 2) { ... }
for (x in 10 downTo 1) { ... }
if (x in 1..10) { ... }

Gestión de tipos nulos

Si no null:

val files = File("Test").listFiles()

println(files?.size)

Si no null con else:

val files = File("Test").listFiles()

println(files?.size ?: "empty")

Ejecutar una declaración si es nulo:

val values = ...
val email = values["email"] ?: throw IllegalStateException("Email is missing!")

Obtener el primer elemento de una colección que puede estar vacía:

val emails = ... // puede estar vacía
val mainEmail = emails.firstOrNull() ?: ""

Ejecutar una declaración si es nulo:

val value = ...

value?.let {
    ... // ejecuta este bloque si no null
}

Valor nulable del mapa si no es nulo:

val value = ...

val mapped = value?.let { transformValue(it) } ?: defaultValueIfValueIsNull

Boolean anulable:

val b: Boolean? = ...
if (b == true) {
    ...
} else {
    // `b` is false or null
}

Funciones

Valores predeterminados para parámetros de función

fun foo(a: Int = 0, b: String = "") { ... }

Declaración de retorno con when:

fun transform(color: String): Int {
    return when (color) {
        "Red" -> 0
        "Green" -> 1
        "Blue" -> 2
        else -> throw IllegalArgumentException("Invalid color param value")
    }
}

Funciones de extensión:

fun String.spaceToCamelCase() { ... }

"Convert this to camelcase".spaceToCamelCase()

Otro ejemplo:

fun String.invertirTexto(): String {
    var textoInvertido = ""
    for (i in (this.length - 1 downTo 0)) {
        textoInvertido = textoInvertido + this.get(i)
    }
    return textoInvertido
}

Métodos que devuelven Unit:

fun arrayOfMinusOnes(size: Int): IntArray {
    return IntArray(size).apply { fill(-1) }
}

Funciones de una sola expresión:

fun theAnswer() = 42

que es equivalente a:

fun theAnswer(): Int {
    return 42
}

Esto se puede combinar con otras expresiones idiomáticas, lo que lleva a un código más corto. Por ejemplo, con la expresión when:

fun transform(color: String): Int = when (color) {
    "Red" -> 0
    "Green" -> 1
    "Blue" -> 2
    else -> throw IllegalArgumentException("Invalid color param value")
}

Función genérica que requiere la información de tipo genérico:

//  public final class Gson {
//     ...
//     public <T> T fromJson(JsonElement json, Class<T> classOfT) throws JsonSyntaxException {
//     ...

inline fun <reified T: Any> Gson.fromJson(json: JsonElement): T = this.fromJson(json, T::class.java)

Clases y objetos

Crear objetos o clases (DTO – Data Transfer Object, POCO – Plain Old CLR Object, POJO Plain Old Java Object) con funcionalidades getters y setters (en caso de var) para todas las propiedades:

data class Cliente(val nombre: String, val email: String)

Comprobación de instancias:

when (x) {
    is Foo -> ...
    is Bar -> ...
    else   -> ...
}

Crear un singleton:

object Resource {
    val nombre = "Nombre"
}

O un objeto anónimo:

val resource = object {
    val nombre = "Kotlin"
}

Llamar a varios métodos en una instancia de objeto (with):

class Turtle {
    fun penDown()
    fun penUp()
    fun turn(degrees: Double)
    fun forward(pixels: Double)
}

val myTurtle = Turtle()
with(myTurtle) { // dibujar un cuadrado de 100 pix
    penDown()
    for(i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}

Acceso a recursos (Java 7)

val stream = Files.newInputStream(Paths.get("/some/file.txt"))
stream.buffered().reader().use { reader ->
    println(reader.readText())
}

Esta entrada es una traducción libre y adaptada de Idioms, a collection of random and frequently used idioms in Kotlin, disponible en la web oficial de Kotlin.

Buscar este blog

Kotlin Doc