Skip to content

3. Fundamentos del lenguaje Kotlin

3.1. Introducción

Comenzaremos tratando Kotlin como un lenguaje de programación tradicional. Las clases las veremos en el capítulo siguiente. Un programa consta de dos cosas:

  • los datos;
  • las instrucciones que los manipulan.

Generalmente procuramos separar los datos de las instrucciones:

Image

Todos los ejemplos de este capítulo forman parte del proyecto Gradle de la carpeta [03-basics] del código del curso. Como se indicó en el capítulo 2, “Configuración del entorno de desarrollo”, cada programa está contenido en un archivo ubicado dentro de un paquete con el nombre del programa en minúsculas: el programa [Basics04.kt] se encuentra en la carpeta [src/main/kotlin/basics04] y comienza con la línea [package basics04]. Puede ejecutarlo haciendo clic en el triángulo verde de IntelliJ IDEA, ubicado en el margen junto a la función [main], o desde la línea de comandos, desde la carpeta del proyecto, con el comando [gradlew -q run -Pmain=basics04.Basics04Kt] ([./gradlew] en Linux y macOS). La opción [-q] (“quiet”) suprime los mensajes de Gradle: solo queda la salida del programa. Explicaremos el nombre [basics04.Basics04Kt] en la siguiente sección. Los ejemplos se ejecutan con las convenciones de idioma y formato franceses (la “configuración regional” fr-FR), como en una máquina Windows francesa. Veremos que esto solo afecta a los números y las fechas formateados con un formato específico: la simple conversión de un número de punto flotante a cadena siempre usa un punto decimal.

3.2. El programa mínimo

3.2.1. La función main de nivel superior

El programa [Basics01.kt] es el siguiente:

// programa mínimo: una función main de nivel superior, escrita fuera de cualquier clase
package basics01

fun main() {
    println("Hello world!")
    // la forma de Java sigue siendo utilizable: el campo out de la clase System y luego su método println
    System.out.println("Hello world!")
    // listOf (paquete kotlin.collections) se puede usar sin importación
    val words = listOf("Hello", "the", "world")
    println(words)
}

Resultados:

1
2
3
4
> gradlew -q run -Pmain=basics01.Basics01Kt
Hello world!
Hello world!
[Hello, the, world]

Comentarios:

  • línea 2: el paquete del programa. Un paquete agrupa declaraciones relacionadas, del mismo modo que una carpeta agrupa archivos. El nombre completo de todo lo declarado en este archivo comienza con [basics01.]. En Kotlin, a diferencia de Java, el directorio del archivo no está dictado por el nombre del paquete; sin embargo, es una práctica habitual, que seguimos, hacer que coincidan;
  • línea 4: la función [main] es el punto de entrada del programa. La palabra clave [fun] declara una función; [main()] no tiene parámetros y no devuelve ningún valor. La función se escribe directamente en el archivo, fuera de cualquier clase: es una función de nivel superior. El cuerpo de la función va entre llaves;
  • línea 5: la función [println] imprime una línea en pantalla. También es una función de nivel superior, declarada en el paquete [kotlin.io] de la biblioteca estándar de Kotlin;
  • línea 7: la versión Java de la misma operación. [System] es una clase del JDK, [out] es uno de sus campos, que representa la salida estándar (la pantalla), y [println] es un método de este objeto. Kotlin utiliza directamente todas las clases de Java: esta es una de sus principales ventajas. La función [println] de Kotlin es, en realidad, solo una abreviatura de [System.out.println]; esta es la que usaremos;
  • línea 9: [words] es una lista de cadenas; las listas se tratarán en el capítulo 5. La palabra clave [val] declara una variable cuyo valor no cambiará; no especificamos su tipo: el compilador lo infiere del valor, en este caso [List<String>]. La función [listOf] pertenece al paquete [kotlin.collections], que puede usarse sin una instrucción de importación (véase más adelante);
  • línea 10: una lista se muestra con sus elementos entre corchetes;
  • las instrucciones no terminan con punto y coma: basta con un salto de línea. El punto y coma solo se usa para escribir varias instrucciones en una misma línea. Las líneas que comienzan con // son comentarios, que el compilador ignora.

Con dos argumentos de línea de comandos, que se pasan a Gradle mediante la opción [--args]:

1
2
3
4
> gradlew -q run -Pmain=basics01.Basics01Kt --args="a0 a1"
Hello world!
Hello world!
[Hello, the, world]

Los argumentos se ignoran porque la función [main()] no tiene parámetros para recibirlos. Para usarlos, declare la función como [fun main(args: Array<String>)]: el arreglo de cadenas [args] contendrá entonces los argumentos de la línea de comandos. Volveremos sobre esto en la sección “Argumentos del programa principal”.

3.2.2. La función main y sus argumentos

El programa [Basics02.kt] es el siguiente:

1
2
3
4
5
6
7
8
9
// la función main con un parámetro: los argumentos de la línea de comandos
package basics02

fun main(args: Array<String>) {
    println("Hello world!")
    println("Number of arguments received: ${args.size}")
    // contentToString construye una cadena con los elementos de un arreglo
    println("Arguments: ${args.contentToString()}")
}

Resultados:

1
2
3
4
> gradlew -q run -Pmain=basics02.Basics02Kt --args="a0 a1"
Hello world!
Number of arguments received: 2
Arguments: [a0, a1]

Comentarios:

  • línea 4: la función [main] recibe los argumentos de la línea de comandos en el parámetro [args]. En Kotlin, el tipo de un parámetro se escribe después de su nombre, separado por dos puntos: [args: Array<String>] se lee “[args], de tipo arreglo de cadenas”. Equivale a [String[] args] en Java;
  • línea 6: el número de elementos del arreglo es [args.size] (el equivalente en Java de [args.length]). En la cadena, [${args.size\}] se reemplaza por el valor de la expresión entre llaves: es una plantilla de cadena, de la que hablaremos con más detalle más adelante;
  • línea 7: la función [contentToString] construye una cadena con los elementos de un arreglo. Reemplaza al método de Java [Arrays.toString] y, como la función anterior, no requiere ninguna importación.

No hemos escrito ninguna clase. Sin embargo, la máquina virtual de Java (JVM), que ejecuta el programa, solo reconoce clases. Por eso el compilador de Kotlin organiza las declaraciones de nivel superior de un archivo en una clase que genera él mismo, cuyo nombre es el del archivo seguido de [Kt]: para el archivo [Basics02.kt] en el paquete [basics02], es la clase [basics02.Basics02Kt]. Por eso el comando de ejecución se refiere al programa como [-Pmain=basics02.Basics02Kt]. Puede comprobarlo compilando el archivo con el compilador de línea de comandos [kotlinc] (capítulo 2) y examinando luego la clase generada con la herramienta [javap] del JDK:

> kotlinc Basics02.kt -d classes
> ls classes/basics02
Basics02Kt.class
> kotlinr -cp classes basics02.Basics02Kt a0 a1
Hello world!
Number of arguments received: 2
Arguments: [a0, a1]
> javap classes/basics02/Basics02Kt.class
Compiled from "Basics02.kt"
public final class basics02.Basics02Kt {
  public static final void main(java.lang.String[]);
}
> java -cp classes basics02.Basics02Kt a0 a1
Exception in thread "main" java.lang.NoClassDefFoundError: kotlin/jvm/internal/Intrinsics
    at basics02.Basics02Kt.main(Basics02.kt)
  • [kotlinc] generó un único archivo de código intermedio (“bytecode”), [Basics02Kt.class], en el directorio del paquete;
  • el comando [kotlinr] (el lanzador de Kotlin, capítulo 2) ejecuta esta clase agregando la biblioteca estándar de Kotlin ([kotlin-stdlib.jar]) a la ruta de clases;
  • [javap] muestra que la clase generada es [public final] y que la función [main] se ha convertido en un método [public static] dentro de ella: exactamente el método [public static void main(String[] args)] que espera la JVM. Para la JVM, un programa Kotlin es simplemente otra clase Java;
  • cuando se inicia con el simple comando [java], la clase falla: el código generado invoca clases de la biblioteca estándar de Kotlin (en este caso, [kotlin.jvm.internal.Intrinsics], que, entre otras cosas, verifica que los parámetros no sean iguales a [null]), que no está en la ruta de clases. Gradle e IntelliJ IDEA la agregan automáticamente; un programa Kotlin independiente debe incluirla (opción [-include-runtime] de [kotlinc], capítulo 2, o scripts de Gradle, véase más adelante).

Para el programa [Basics01.kt], cuya función [main] no tiene parámetros, el compilador también genera un método [main(String[])] que simplemente llama al primero. Gradle coloca las clases que compila en la carpeta [build/classes/kotlin/main] del proyecto; puede examinarlas allí después de una compilación ([gradlew build]):

1
2
3
4
5
6
> javap -cp build/classes/kotlin/main basics01.Basics01Kt
Compiled from "Basics01.kt"
public final class basics01.Basics01Kt {
  public static final void main();
  public static void main(java.lang.String[]);
}

Una comparación con Java 25 resulta instructiva. Java 25 también permite escribir un programa sin declarar una clase (un “archivo fuente compacto”, con un método llamado [void main()]): el compilador de Java envuelve entonces el contenido del archivo en una clase implícita que lleva el nombre del archivo. Kotlin hace lo mismo desde su primera versión, con dos diferencias:

  • la clase generada se llama [Basics02Kt] en lugar de [Basics02], lo que deja el nombre [Basics02] disponible para una clase que el programador quiera escribir por su cuenta en el mismo archivo. La anotación ***[@file:JvmName("ClassName")]***, colocada al principio del archivo, permite elegir un nombre distinto;
  • las funciones de nivel superior se compilan como métodos [static]: no se crea ningún objeto para llamar a [main], mientras que el método [void main()] de un archivo Java compacto es un método de instancia. Lo más importante: en Kotlin, esta sintaxis no se limita a programas pequeños: las funciones, variables y constantes de nivel superior se usan comúnmente en todos los programas, junto con las clases.

La función [main] solo puede tener las dos formas ya vistas: [fun main()] y [fun main(args: Array<String>)]. No necesita declararse pública: en Kotlin, todo es público de manera predeterminada.

3.2.3. Importaciones predeterminadas

El programa [Basics01.kt] usa las funciones [println] y [listOf], y el programa [Basics02.kt] usa la función [contentToString], sin ninguna directiva [import]. Esto es posible porque todo archivo Kotlin importa automáticamente los siguientes paquetes de la biblioteca estándar:

import kotlin.*
import kotlin.annotation.*
import kotlin.collections.*
import kotlin.comparisons.*
import kotlin.io.*
import kotlin.ranges.*
import kotlin.sequences.*
import kotlin.text.*
// and, for the JVM:
import java.lang.*
import kotlin.jvm.*

Esto proporciona los tipos básicos ([Int], [String]... del paquete [kotlin]), listas, conjuntos y diccionarios ([kotlin.collections]), entrada y salida por consola ([kotlin.io]), intervalos ([kotlin.ranges]), funciones de cadenas ([kotlin.text]), así como las clases del paquete Java [java.lang] ([System], [Math], [Thread]...). Cualquier otra declaración debe importarse al inicio del archivo, inmediatamente después de la línea [package]: una directiva por clase o función ([import java.math.BigDecimal]) o una directiva por paquete ([import java.time.*]). No existe un equivalente de la directiva [import module java.base;] de Java 25, que un archivo Java compacto recibe automáticamente: un programa Kotlin que use las clases [BigDecimal] o [LocalDate] del JDK debe importarlas. Una observación sobre la sintaxis: las directivas [import], como las demás instrucciones, no terminan con punto y coma.

3.3. Tipos de datos de Kotlin

Kotlin utiliza los siguientes tipos de datos:

  • enteros, con signo y sin signo;
  • números reales;
  • números decimales;
  • caracteres y cadenas de caracteres;
  • booleanos;
  • objetos.

3.3.1. Tipos de datos predefinidos

Tipo de Kotlin
Tipo de Java correspondiente
Datos representados
Sufijo del literal
Codificación
Rango de valores
[Char]
[char] / [Character]
carácter
 
2 bytes
Carácter Unicode (UTF-16), de '\u0000' a '\uFFFF'
[Byte]
[byte] / [Byte]
entero
 
1 byte
[-2⁷, 2⁷-1] o [-128, 127]
[Short]
[short] / [Short]
entero
 
2 bytes
[-2¹⁵, 2¹⁵-1] o [-32768, 32767]
[Int]
[int] / [Integer]
entero
 
4 bytes
[-2³¹, 2³¹-1] o [-2147483648, 2147483647]
[Long]
[long] / [Long]
entero
L
8 bytes
[-2⁶³, 2⁶³-1] o [-9223372036854775808, 9223372036854775807]
[UByte], [UShort], [UInt], [ULong]
(sin equivalente)
entero sin signo
U, UL
1, 2, 4, 8 bytes
[0, 2⁸-1], [0, 2¹⁶-1], [0, 2³²-1], [0, 2⁶⁴-1]
[Float]
[float] / [Float]
número real
F
4 bytes
[1.4 10⁻⁴⁵, 3.4 10³⁸] en valor absoluto, 7 dígitos significativos
[Double]
[double] / [Double]
número real
 
8 bytes
[4.9 10⁻³²⁴, 1.8 10³⁰⁸] en valor absoluto, de 15 a 16 dígitos significativos
[Boolean]
[boolean] / [Boolean]
booleano
 
no definido
[true], [false]
[String]
[String]
cadena de caracteres
  
referencia a una secuencia de caracteres Unicode
[BigDecimal] (clase de Java)
[BigDecimal]
número decimal
 
variable
número decimal exacto, de cualquier precisión
[Any]
[Object]
referencia a un objeto
  
referencia a un objeto de cualquier tipo

Java distingue entre los ocho tipos primitivos ([int], [double]...), cuyos valores no son objetos, y los tipos de referencia (clases), y asocia a cada tipo primitivo una clase envoltorio ([Integer] para [int]...). Kotlin elimina esta distinción: en Kotlin, todo valor es un objeto. El tipo [Int] es una clase que tiene métodos; se puede escribir [3.plus(4)] o [3.toString()], algo que Java no permite para el literal 3 de tipo [int]. Los nombres de los tipos comienzan todos con mayúscula, igual que los nombres de las clases.

Esto no tiene ningún impacto en el rendimiento en tiempo de ejecución. El compilador traduce una variable de tipo [Int] en una variable del tipo primitivo [int] de la JVM siempre que sea posible, y utiliza la clase envoltorio *[java.lang.Integer] solo cuando se requiere un objeto: cuando el valor se pasa a un parámetro de tipo [Any] (el equivalente en Kotlin de la clase de Java [Object]), se almacena en una lista, o cuando puede ser de tipo [null] (véase más adelante). Por lo tanto, el boxing y el unboxing siguen presentes, pero los gestiona el compilador y el programador Kotlin no tiene que preocuparse por ello. En Kotlin no existe el tipo [Integer]: solo existe [Int]*.

Los tamaños en bytes los dan las constantes [Int.SIZE_BYTES], [Long.SIZE_BYTES]... (y [Int.SIZE_BITS]... en bits), los límites del rango mediante [Int.MIN_VALUE] y [Int.MAX_VALUE], etc.

A diferencia de Java, Kotlin tiene enteros sin signo: [UByte], [UShort], [UInt] y [ULong], que tienen el mismo tamaño que sus equivalentes con signo, pero representan solo valores positivos o cero. Sus literales llevan el sufijo U ([42U]) o UL ([42UL]). Se usan principalmente para manipular datos binarios (bytes de archivos, direcciones, colores); los cálculos comunes se realizan con tipos con signo. Kotlin tampoco tiene un tipo decimal: los importes se calculan con la clase [BigDecimal] del paquete Java [java.math], que veremos un poco más adelante.

El programa [Basics03.kt] ilustra estos diversos puntos:

// los tipos básicos: nombre en Kotlin, clase de Java y tamaño en bytes
package basics03

import java.math.BigDecimal

fun main() {
    val integer: Int = 2
    val fl: Float = 10.5F
    val d: Double = -4.6
    val s: String = "test"
    val l: Long = 1000
    val bt: Byte = 5
    val sh: Short = -4
    val c: Char = 'A'
    val b: Boolean = true
    val dec: BigDecimal = BigDecimal("10.67")
    // en una cadena, $name y ${expression} se reemplazan por su valor
    println("Type of integer[$integer] : [${typeName(integer)},${Int.SIZE_BYTES}]")
    println("Type of fl[$fl] : [${typeName(fl)},${Float.SIZE_BYTES}]")
    println("Type of d[$d] : [${typeName(d)},${Double.SIZE_BYTES}]")
    println("Type of s[$s] : [${typeName(s)}]")
    println("Type of l[$l] : [${typeName(l)},${Long.SIZE_BYTES}]")
    println("Type of bt[$bt] : [${typeName(bt)},${Byte.SIZE_BYTES}]")
    println("Type of sh[$sh] : [${typeName(sh)},${Short.SIZE_BYTES}]")
    println("Type of c[$c] : [${typeName(c)},${Char.SIZE_BYTES}]")
    println("Type of b[$b] : [${typeName(b)}]")
    println("Type of dec[$dec] : [${typeName(dec)}]")
    // el literal 3 es un objeto: tiene métodos
    println("The literal 3 : ${3::class.simpleName}, 3.plus(4)=${3.plus(4)}, 3.toString()=${3.toString()}")
    // valores extremos
    println("Int : [${Int.MIN_VALUE}, ${Int.MAX_VALUE}]")
    println("Long : [${Long.MIN_VALUE}, ${Long.MAX_VALUE}]")
    println("Double : [${Double.MIN_VALUE}, ${Double.MAX_VALUE}]")
    // enteros sin signo: UByte, UShort, UInt, ULong
    val u: UInt = 4_000_000_000U
    println("u=$u, UInt : [${UInt.MIN_VALUE}, ${UInt.MAX_VALUE}], ULong.MAX_VALUE=${ULong.MAX_VALUE}")
    val minusOne = -1
    println("-1 read as an unsigned integer: ${minusOne.toUInt()}")
}

// devuelve el nombre en Kotlin y el nombre de la clase de Java del objeto recibido
fun typeName(o: Any): String {
    return "${o::class.qualifiedName},${o.javaClass.name}"
}

Resultados:

> gradlew -q run -Pmain=basics03.Basics03Kt
Type of integer[2] : [kotlin.Int,java.lang.Integer,4]
Type of fl[10.5] : [kotlin.Float,java.lang.Float,4]
Type of d[-4.6] : [kotlin.Double,java.lang.Double,8]
Type of s[test] : [kotlin.String,java.lang.String]
Type of l[1000] : [kotlin.Long,java.lang.Long,8]
Type of bt[5] : [kotlin.Byte,java.lang.Byte,1]
Type of sh[-4] : [kotlin.Short,java.lang.Short,2]
Type of c[A] : [kotlin.Char,java.lang.Character,2]
Type of b[true] : [kotlin.Boolean,java.lang.Boolean]
Type of dec[10.67] : [java.math.BigDecimal,java.math.BigDecimal]
The literal 3 : Int, 3.plus(4)=7, 3.toString()=3
Int : [-2147483648, 2147483647]
Long : [-9223372036854775808, 9223372036854775807]
Double : [4.9E-324, 1.7976931348623157E308]
u=4000000000, UInt : [0, 4294967295], ULong.MAX_VALUE=18446744073709551615
-1 read as an unsigned integer: 4294967295

Comentarios:

  • Línea 4: la clase [BigDecimal] es una clase del JDK; debe importarse;
  • línea 7: declaración de una variable [integer] de tipo [Int] inicializada en 2. En Kotlin, el tipo de una variable se escribe después de su nombre, separado por dos puntos. Veremos que normalmente el tipo puede omitirse;
  • línea 8: el sufijo F es obligatorio: el literal 10.5 es de tipo [Double], y el compilador se niega a asignarlo a una variable de tipo [Float];
  • línea 11: el literal 1000 se acepta para una variable de tipo [Long], porque el compilador sabe que es una constante que cabe en el tipo. Lo mismo ocurre en las líneas 12–13 para los tipos [Byte] y [Short]. Sin embargo, como veremos, Kotlin nunca convierte implícitamente una variable de un tipo numérico a otro;
  • línea 16: un número [BigDecimal] es un objeto; aquí se crea a partir de una cadena, lo que garantiza un valor exacto. Kotlin no tiene un operador [new]: un objeto se crea llamando al constructor de su clase como si fuera una función;
  • línea 18: en una cadena, [$integer] se reemplaza por el valor de la variable [integer], y [${typeName(integer)\}] por el valor de la expresión escrita entre llaves. Estas plantillas de cadena son la forma estándar de construir una cadena en Kotlin; volveremos sobre esto en la próxima sección. [Int.SIZE_BYTES] es el tamaño en bytes de un [Int];
  • Línea 18: la función [typeName] (líneas 42–43) espera un parámetro de tipo [Any]. Por lo tanto, el parámetro es un objeto, y el valor [integer] se envuelve en un objeto [java.lang.Integer]. La función muestra dos nombres: [o::class.qualifiedName] es el nombre completo del tipo para Kotlin ([kotlin.Int]), y [o.javaClass.name] es el nombre de la clase del objeto para la JVM ([java.lang.Integer]). Se puede ver que [kotlin.Int], [kotlin.Double], [kotlin.String]... se representan en tiempo de ejecución mediante clases de Java;
  • línea 21: el tamaño de una cadena en memoria no es accesible: [String] no tiene una constante [SIZE_BYTES];
  • línea 26: la JVM no define el tamaño de un booleano: [Boolean] no tiene una constante [SIZE_BYTES];
  • línea 27: [BigDecimal] es una clase de Java: sus dos nombres son idénticos;
  • línea 29: el literal 3 es un objeto de tipo [Int]: [3::class.simpleName] es el nombre corto de su tipo, y se pueden llamar sus métodos [plus] y [toString]. Veremos en el Capítulo 4 que el operador + es simplemente otra forma de escribir el método [plus];
  • líneas 31–33: las constantes [MIN_VALUE] y [MAX_VALUE] especifican los límites del dominio de valores. Nota: para los números reales, [Double.MIN_VALUE] es el valor estrictamente positivo más pequeño (4.9 × 10⁻³²⁴) y no el mayor número negativo, que es [-Double.MAX_VALUE];
  • línea 35: un entero sin signo de 32 bits. El valor 4,000,000,000 excede el rango de [Int], pero no el de [UInt], que llega hasta 2³²-1;
  • líneas 37–38: -1 se codifica como 32 bits en 1; la función [toUInt] los interpreta como un entero sin signo, que es igual a 2³²-1;
  • Líneas 42–43: una función de nivel superior del archivo. El tipo de retorno se especifica después de la lista de parámetros: [: String]. Devuelve ([return]) una cadena de caracteres. Las funciones se describen en la sección “Paso de parámetros a una función”.

Observe que los números reales se muestran con punto decimal (10.5, -4.6), aunque el programa se ejecute en francés. Convertir un número en cadena —ya sea mediante una plantilla, una concatenación o el método [toString]— no depende del idioma del usuario: siempre produce un punto decimal. Solo los formatos numéricos como %f, que veremos más adelante, siguen las convenciones del idioma.

3.3.2. Notación de los datos literales

Datos
Ejemplos de literales
[Int] entero (32 bits)
145, -7, 0xFF (hexadecimal), 0b1010_1010 (binario)
Entero [Long] (64 bits), sufijo L
100000L, 1_000_000_000_000L, 3_000_000_000 (demasiado grande para un [Int])
entero sin signo [UInt], [ULong], sufijo U, UL
255U, 0xFFFF_FFFFU, 1UL
real [Double]
134.789, -45E-18 (-45 × 10⁻¹⁸), 10.0
real [Float], sufijo F o f
134.789F, -45E-18F
número decimal [BigDecimal]
sin literal: [BigDecimal("100000.50")]
carácter [Char]
'A', 'b', '\n', '\u00e9'
cadena [String]
"today", "c:\\chap1", "$name is ${age + 10\} years old", cadena sin procesar """c:\chap1"""
booleano [Boolean]
[true], [false]
fecha
[LocalDate.of(1954, 10, 13)] (año, mes, día) para el 10/13/1954

En el código fuente, los números de punto flotante siempre se escriben con punto decimal. Al igual que en Java, los enteros pueden escribirse en hexadecimal (prefijo [0x]) o en binario (prefijo [0b]), y los grupos de dígitos pueden separarse con el carácter _ para mejorar la legibilidad: [1_000_000] es el entero un millón. Kotlin se diferencia de Java en algunos aspectos, que eliminan otras tantas trampas:

  • un literal entero sin sufijo es de tipo [Int] si cabe en ese tipo, y de tipo [Long] en caso contrario: [3_000_000_000] es un [Long]. Java rechaza este literal sin el sufijo L;
  • el sufijo L debe escribirse en mayúscula: el compilador rechaza [100l] con el mensaje [use 'L' instead of 'l'], porque la l se parece demasiado al dígito 1;
  • no existe la notación octal. La trampa de Java, donde 017 es igual a 15, no existe: el compilador rechaza 017 con el mensaje [leading zeros are not allowed in integer literals];
  • no existe el sufijo “D” para los números de punto flotante: un literal que contiene un punto decimal o un exponente es [Double]; por lo tanto, 10.0 se escribe 10.0 y no 10D;
  • Los enteros sin signo tienen sus propios sufijos, U y UL.

Un literal de cadena puede contener secuencias de escape introducidas por el carácter \: "\n" representa el carácter de fin de línea y no la secuencia de los dos caracteres \ y n, "\t" representa un tabulador, "\"" representa una comilla doble, "\\" el propio carácter \, "\$" el carácter $ (véase más adelante), y "\u00e9" el carácter Unicode con código hexadecimal 00E9. Por lo tanto, para escribir la ruta de Windows c:\chap1\paragraph3, debe escribirse "c:\\chap1\\paragraph3". Las clases de archivos de Java también aceptan el separador / en Windows: "c:/chap1/paragraph3" designa el mismo archivo.

Para construir una cadena a partir de varios valores, Kotlin ofrece tres métodos:

  • plantillas de cadena: en una cadena, [$name] se reemplaza por el valor de la variable [name], y [${expression\}] por el valor de cualquier expresión: ["in 10 years he will be ${age + 10\}"]. Es el método más legible y más utilizado. Equivale a las cadenas interpoladas de C#, como [$"..."]; Java, en cambio, no tiene esta característica (las “plantillas de cadena” propuestas como vista previa en Java 21 y 22 se eliminaron);
  • la concatenación con el operador +: si el operando izquierdo es una cadena, el operando derecho se convierte en cadena, sea cual sea su tipo. A diferencia de Java, el operando izquierdo debe ser una cadena: [10 + " years"] es rechazado por el compilador porque el tipo [Int] no tiene un operador + que acepte una cadena;
  • los formatos: ["format".format(value1, value2, ...)] o [String.format(format, value1, value2, ...)]. Son los formatos de Java, con los mismos especificadores, que se reemplazan en orden por los valores siguientes: %s (cualquier valor convertido en cadena), %d (un entero), %f (un número de punto flotante), %.2f (un número de punto flotante con dos decimales), %x o %X (un entero en hexadecimal), %,d (un entero con separador de miles), %e (notación científica), %n (un salto de línea), %10s (una cadena alineada a la derecha en 10 caracteres), %-10s (alineada a la izquierda)... Los formatos numéricos siguen las convenciones del idioma del usuario. Se utilizan cuando se necesita controlar la presentación de los números (cantidad de decimales, alineación); de lo contrario, basta con la plantilla.

Por último, Kotlin ofrece “cadenas sin procesar” (raw strings): una cadena delimitada por tres comillas, como ["""..."""], puede ocupar varias líneas y contener comillas; sobre todo, las secuencias de escape no se interpretan en las cadenas sin procesar: el carácter \ se trata tal cual, de modo que se escribiría ["""c:\chap1"""]. Esto es muy útil para escribir JSON, SQL, HTML o expresiones regulares (Capítulo 5). Las cadenas sin procesar admiten plantillas. Los espacios iniciales se conservan tal cual; para sangrar el texto junto con el código, se aplica a la cadena la función [trimIndent()], que elimina los espacios comunes a todas las líneas así como la primera y la última línea si están vacías, o la función [trimMargin()], que elimina todo lo que precede al carácter | (el “margen”). Los bloques de texto de Java 15 se diseñaron según este modelo; eliminan automáticamente la sangría común, pero interpretan las secuencias de escape.

El programa [Basics04.kt] muestra estas diferentes notaciones:

// la notación de los datos literales
package basics04

import java.math.BigDecimal
import java.time.LocalDate
import java.time.format.DateTimeFormatter

fun main() {
    // enteros: decimal, hexadecimal (0x), binario (0b), separador _
    val i1 = 145; val i2 = -7; val i3 = 0xFF; val i4 = 0b1010_1010
    val l1 = 100000L; val l2 = 1_000_000_000_000L; val l3 = 3_000_000_000
    println("integers: $i1 $i2 $i3 $i4 $l1 $l2 $l3")
    // enteros sin signo: sufijo U
    val u1 = 255U; val u2 = 0xFFFF_FFFFU
    println("unsigned: $u1 $u2")
    // reales
    val d1 = 134.789; val d2 = -45E-18; val d3 = 10.0
    val f1 = 134.789F
    val m1 = BigDecimal("100000.50")
    println("reals: $d1 $d2 $d3 $f1 $m1")
    // caracteres y booleanos
    val c1 = 'A'; val c2 = '\u00e9'
    val b1 = true
    println("characters: $c1 $c2, boolean: $b1")
    // una fecha: (año, mes, día)
    val birth = LocalDate.of(1954, 10, 13)
    println("date: $birth")

    // el carácter \ introduce una secuencia de escape
    val path = "c:\\chap1\\paragraph3"
    println(path)
    println("line 1\nline 2\t[tab]")
    // el carácter $ se escribe \$ en una cadena
    println("price: 10 \$, quotes: \"yes\"")

    // construcción de una cadena: plantilla, concatenación o formato
    val name = "dupont"
    val age = 23
    println("$name is $age years old, in 10 years he will be ${age + 10}")
    println(name + " is " + age + " years old, in 10 years he will be " + (age + 10))
    println(String.format("%s is %d years old, in 10 years he will be %d", name, age, age + 10))
    // la función format se aplica a la propia cadena de formato
    println("d1=%.1f, i3 in hexadecimal=%X, l2=%,d".format(d1, i3, l2))
    println("i4 in binary=${i4.toString(2)}, name in upper case=${name.uppercase()}")
    println("date=${birth.format(DateTimeFormatter.ofPattern("EEEE d MMMM yyyy"))}")

    // cadena sin procesar: sin secuencias de escape, sin comillas que escapar
    val json = """
        {
          "name": "dupont",
          "path": "c:\chap1"
        }
        """.trimIndent()
    println(json)
    // una cadena sin procesar acepta plantillas
    val json2 = """{ "name": "$name", "age": $age }"""
    println(json2)
    // trimMargin: el margen termina en el carácter |
    val text = """
        |A raw string
        |   on several lines, costing 10 ${'$'}
        """.trimMargin()
    println(text)
}

Resultados:

> gradlew -q run -Pmain=basics04.Basics04Kt
integers: 145 -7 255 170 100000 1000000000000 3000000000
unsigned: 255 4294967295
reals: 134.789 -4.5E-17 10.0 134.789 100000.50
characters: A é, boolean: true
date: 1954-10-13
c:\chap1\paragraph3
line 1
line 2    [tab]
price: 10 $, quotes: "yes"
dupont is 23 years old, in 10 years he will be 33
dupont is 23 years old, in 10 years he will be 33
dupont is 23 years old, in 10 years he will be 33
d1=134,8, i3 in hexadecimal=FF, l2=1 000 000 000 000
i4 in binary=10101010, name in upper case=DUPONT
date=mercredi 13 octobre 1954
{
  "name": "dupont",
  "path": "c:\chap1"
}
{ "name": "dupont", "age": 23 }
A raw string
   on several lines, costing 10 $

Comentarios:

  • líneas 4–6: se importan las clases del JDK que utiliza el programa;
  • Línea 10: cuatro declaraciones en una sola línea, separadas por punto y coma. [0xFF] es 255 y [0b1010_1010] es 170. No se especifican los tipos de las variables: el compilador los infiere a partir de los valores, en este caso [Int];
  • línea 11: el sufijo L convierte 100000 en un [Long]. El literal 3_000_000_000, que es demasiado grande para un [Int], es un [Long] sin necesidad de sufijo;
  • línea 14: dos enteros sin signo de tipo [UInt]. 0xFFFF_FFFFU, que tiene los 32 bits en 1, es igual a 2³²-1;
  • línea 17: -45E-18 se muestra como -4.5E-17: es el mismo valor, normalizado. El número de punto flotante 10.0 se muestra como 10.0: convertir un [Double] en cadena siempre produce al menos un decimal;
  • línea 19: un [BigDecimal] conserva la cantidad de decimales con la que se escribió: 100000.50, no 100000.5;
  • línea 22: la secuencia \u00e9 designa el carácter Unicode con código hexadecimal 00E9, es decir, é;
  • línea 26: una fecha. La clase [LocalDate] (paquete [java.time] del JDK) representa una fecha sin hora. Kotlin no tiene su propia clase de fecha: utiliza la de Java. Su conversión a cadena usa el formato internacional ISO 8601 (año-mes-día), sea cual sea el idioma. Veremos las fechas en el Capítulo 5;
  • línea 30: cada \\ representa un solo carácter \;
  • línea 32: un salto de línea y un tabulador;
  • línea 34: las secuencias \$ y \";
  • línea 39: una plantilla. [$name] y [$age] se reemplazan por los valores de las variables, y [${age + 10\}] por el valor de la expresión. Las llaves son obligatorias siempre que lo que sigue al $ no sea un simple nombre de variable;
  • línea 40: el mismo texto construido por concatenación. Los paréntesis alrededor de [(age + 10)] son esenciales: sin ellos, los operadores + se evaluarían de izquierda a derecha, la cadena recibiría primero 23 y luego 10, y el resultado sería “in 10 years he will be 2310”. La plantilla no tiene esta trampa;
  • línea 41: el mismo texto construido mediante un formato;
  • línea 43: algunos especificadores de formato: %.1f (un decimal), %X (hexadecimal en mayúsculas), %,d (separador de miles). Estos formatos siguen las convenciones francesas: una coma decimal y, como separador de miles, un espacio fino sin salto. La función [format] de la biblioteca de Kotlin se aplica a la propia cadena de formato; llama a la función de Java [String.format];
  • línea 44: la función [toString(base)] convierte un entero en cadena en cualquier base, aquí 2; la función [uppercase()] convierte la cadena a mayúsculas. Observe que una plantilla puede contener llamadas a funciones;
  • línea 45: un formato de fecha personalizado: día de la semana (EEEE), día (d), mes en letras (MMMM), año (yyyy). Los nombres de los días y de los meses están en francés, el idioma del usuario. Observe que la plantilla puede contener comillas dentro de las llaves;
  • Líneas 48–53: una cadena sin procesar que ocupa varias líneas. Las comillas se escriben tal cual, y no fue necesario escribir \chap1 como \\chap1. La función [trimIndent()] eliminó los ocho espacios comunes a todas las líneas, así como la primera línea (que está vacía, inmediatamente después de las comillas de apertura) y la última línea (que contiene solo espacios antes de las comillas de cierre);
  • línea 56: una cadena sin procesar en una sola línea, que evita tener que escapar las comillas en JSON, con dos plantillas;
  • líneas 59–62: la función [trimMargin()] elimina, de cada línea, los espacios y el carácter | que marcan el margen: los tres espacios colocados después del | se conservan. Como las secuencias de escape no se interpretan en una cadena sin procesar, el carácter $ se escribe como [${'$'\}]: una plantilla cuya expresión es el carácter '$'. Aquí, como el $ va seguido de un salto de línea, podría haberse escrito solo; sin embargo, [$name] se reemplazaría por el valor de [name]. Desde Kotlin 2.2, también se puede prefijar la cadena con varios signos $: en [$$"""{ "$schema": "$$name" \}"""], se requieren dos signos $ para introducir una plantilla, y [$schema] permanece sin cambios.

3.3.3. Declaración de datos

3.3.3.1. Función de las declaraciones

Un programa manipula datos caracterizados por un nombre y un tipo. Estos datos se almacenan en memoria. Cuando se compila el programa, el compilador asigna a cada dato una ubicación de memoria caracterizada por una dirección y un tamaño. Lo hace a partir de las declaraciones realizadas por el programador. Además, estas declaraciones permiten al compilador detectar errores de programación. Así, la operación [x = x * 2] se declarará inválida si [x] es una cadena de caracteres.

3.3.3.2. Variables de solo lectura y mutables

Kotlin tiene dos palabras clave para declarar una variable:

  • [val] (“value”) declara una variable de solo lectura: se le asigna un valor una sola vez y no puede modificarse después. Equivale a una variable Java [final];
  • [var] (“variable”) declara una variable mutable, a la que se le pueden asignar nuevos valores.

La sintaxis es la siguiente:

val name: Type = value
var name: Type = value

El tipo normalmente se omite: el compilador lo infiere entonces a partir del valor (inferencia de tipos). Por lo tanto, la palabra clave de Kotlin [var] no tiene el mismo significado que en Java 10: en Java, [var] significa “tipo inferido”; en Kotlin, significa “mutable”, y el tipo puede inferirse con [val] igual que con [var]. Una variable declarada sin inicializarse debe tener un tipo explícito; no puede usarse hasta que se le haya asignado un valor (mensaje [variable 'b' must be initialized]).

La convención en Kotlin es declarar todas las variables con [val], y usar [var] solo cuando realmente se espera que el valor de la variable cambie. Esto mejora la legibilidad del programa: al leer ***[val total = ...]***, se sabe que *[total] conservará ese valor. IntelliJ IDEA también ayuda a identificar cualquier variable declarada con [var] que en realidad podría ser [val]*.

Kotlin distingue entre mayúsculas y minúsculas: las variables [END] y [end] son diferentes. Por convención, el nombre de una variable comienza con una letra minúscula, y cada palabra siguiente comienza con una letra mayúscula: [priceExclTax], [nbChildren].

3.3.3.3. Declaración de constantes

Una variable como [val] no cambia su valor, pero su valor puede no conocerse hasta el momento de la ejecución ([val today = LocalDateTime.now()]). Una constante, en sentido estricto, es un valor conocido en tiempo de compilación. Kotlin la declara con las palabras clave [const val]:

const val NAME = value

Una constante [const val] se declara en el nivel superior del archivo (fuera de las funciones), o dentro de un [object] o de un [companion object], que veremos en el Capítulo 4. Solo puede ser de un tipo básico ([Int], [Double], [Boolean]...) o de tipo [String], y su valor debe poder ser calculado por el compilador. Por ejemplo:

const val VAT_RATE = 0.2

El compilador reemplaza entonces cada aparición de [VAT_RATE] por su valor, igual que hace el compilador de Java con un campo [static final] inicializado con una constante. Los siguientes intentos son rechazados:

1
2
3
4
5
const val START = LocalDate.of(2026, 1, 1)
error: const 'val' has type 'LocalDate!'. Only primitive types and 'String' are allowed.
fun main() {
    const val N = 3
error: modifier 'const' is not applicable to 'local variable'.

(el signo de exclamación en [LocalDate!] se explicará en la próxima sección). ¿Por qué declarar constantes?

  • El programa es más fácil de leer si se le da a la constante un nombre significativo;
  • es más fácil modificar el programa si es necesario cambiar la “constante”. Así, si la tasa de IVA cambia a 0.25, la única modificación necesaria es en la instrucción que define su valor: [const val VAT_RATE = 0.25]. Si se hubiera usado 0.2 explícitamente en el programa, habría que modificar numerosas instrucciones.

Por convención, como en Java, el nombre de una constante se escribe en mayúsculas, con las palabras separadas por el carácter _: [VAT_RATE], [MAX_VALUE]. Una variable local, como [val], conserva un nombre normal.

El programa [Basics05.kt] es el siguiente:

// constantes y variables
package basics05

import java.time.LocalDateTime

// una constante de nivel superior: const val, nombre en mayúsculas
const val VAT_RATE = 0.2

fun main() {
    // una variable de solo lectura: val
    val currency = "euros"
    // una variable mutable: var
    var priceExclTax = 100.0
    println("Price incl. tax: ${priceExclTax * (1 + VAT_RATE)} $currency")
    priceExclTax = 250.0
    println("Price incl. tax: ${priceExclTax * (1 + VAT_RATE)} $currency")

    // un dato con tipo explícito
    val i: Int = 2
    println("Type of val i: Int = 2 : ${typeName(i)}")
    // datos con tipo implícito: el tipo se infiere a partir del valor
    val j = 3
    println("Type of val j = 3 : ${typeName(j)}")
    val today = LocalDateTime.now()
    println("Type of val today : ${typeName(today)}")
    val x = 3.5
    val y = 3.5F
    val z = 10L
    val name = "dupont"
    println("x : ${typeName(x)}, y : ${typeName(y)}")
    println("z : ${typeName(z)}, name : ${typeName(name)}")
    // una variable declarada sin valor inicial: su tipo debe escribirse
    val b: Int
    val a = 1
    val c = 3
    b = a + c
    println("a=$a, b=$b, c=$c")
}

// devuelve el nombre corto y el nombre completo del tipo del objeto recibido
fun typeName(o: Any): String = "${o::class.simpleName},${o::class.qualifiedName}"

Resultados:

1
2
3
4
5
6
7
8
9
> gradlew -q run -Pmain=basics05.Basics05Kt
Price incl. tax: 120.0 euros
Price incl. tax: 300.0 euros
Type of val i: Int = 2 : Int,kotlin.Int
Type of val j = 3 : Int,kotlin.Int
Type of val today : LocalDateTime,java.time.LocalDateTime
x : Double,kotlin.Double, y : Float,kotlin.Float
z : Long,kotlin.Long, name : String,kotlin.String
a=1, b=4, c=3

Comentarios:

  • línea 7: una constante de nivel superior. El compilador la ubica en la clase [Basics05Kt] como un campo [public static final double];
  • línea 11: una variable local de solo lectura, de tipo [String] (inferido);
  • línea 13: una variable mutable. El literal 100.0 le da a [priceExclTax] el tipo [Double]. Con [var priceExclTax = 100], la variable sería de tipo [Int], y la asignación de 250.0 en la línea 15 sería rechazada;
  • línea 14: el resultado es un [Double], que se muestra con al menos un decimal: 120.0;
  • línea 15: a [priceExclTax] se le asigna un nuevo valor;
  • línea 19: un dato con tipo explícito;
  • línea 20: la función [typeName] (línea 41) muestra el nombre corto ([simpleName]) y el nombre completo ([qualifiedName]) del tipo de su parámetro;
  • línea 22: un valor con tipo implícito. Como 3 es de tipo [Int], [j] será de tipo [Int];
  • línea 24: como [LocalDateTime.now()] (la fecha y hora actuales) es de tipo [LocalDateTime], [today] será de tipo [LocalDateTime]. Observe que el programa llama a un método [static] de una clase de Java, igual que en Java: [LocalDateTime.now()];
  • líneas 26–29: el tipo inferido depende de cómo se escribe el literal: 3.5 es un [Double], 3.5F es un [Float], 10L es un [Long];
  • Línea 33: una variable declarada sin valor inicial; su tipo es obligatorio. Aunque se declara como [val], se le puede asignar un valor más tarde (línea 36), pero solo una vez. Kotlin no permite declarar varias variables en una sola instrucción, como en el [int a = 1, b, c = 3;] de Java: se escribe una declaración por línea, o varias declaraciones separadas por punto y coma, como en el programa anterior;
  • Línea 41: una función cuyo cuerpo se reduce a una sola expresión puede escribirse usando el signo igual (=) en lugar de llaves y del cuerpo de expresión. Incluso se podría omitir el tipo de retorno, que el compilador inferiría a partir de la expresión.

A una variable [val] no se le puede asignar un nuevo valor, y una variable [var] no puede cambiar de tipo: su tipo quedó fijado por su declaración. Por lo tanto, el compilador rechaza las siguientes instrucciones:

1
2
3
4
5
6
val today = LocalDateTime.now()
today = LocalDateTime.now()
error: 'val' cannot be reassigned.
var counter = 0
counter = "one"
error: assignment type mismatch: actual type is 'String', but 'Int' was expected.

3.3.4. Seguridad frente a nulos (null safety)

A veces es útil poder expresar la ausencia de un valor: una edad desconocida, un campo vacío en una base de datos o una búsqueda fallida. En Java, cualquier variable de un tipo de referencia puede tener el valor [null], que significa “ningún objeto”. Intentar acceder a un miembro de esa variable —por ejemplo, su método [length()]— provoca un error en tiempo de ejecución, una [NullPointerException]: es el error más frecuente en Java, porque el compilador de Java no distingue entre una referencia que puede ser [null] y una que no. Para expresar la ausencia de un valor sin [null], Java 8 agregó la clase [Optional<T>], una “caja” que contiene un valor o está vacía; y para un número, Java usa la clase envoltorio [Integer], que puede contener [null], en lugar del tipo primitivo [int].

Kotlin resuelve este problema dentro del propio sistema de tipos, y este es uno de sus principales aportes. Un tipo normal no admite el valor null: una variable de tipo [String] siempre contiene una cadena, y una variable de tipo [Int] siempre contiene un entero. Para permitir [null], hay que indicarlo explícitamente agregando un signo de interrogación al nombre del tipo: [String?] es el tipo “cadena o null”, y [Int?] es el tipo “entero o null”. Se los conoce como tipos “nullable” (anulables). El compilador verifica entonces que no se pueda usar un miembro de un valor anulable sin antes tratar el caso [null]:

1
2
3
4
5
6
7
val name: String = null
error: null cannot be a value of a non-null type 'String'.
val firstName: String? = firstNameOf("martin")
println(firstName.length)
error: only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type 'String?'.
val n: Int = "12".toIntOrNull()
error: initializer type mismatch: expected 'Int', actual 'Int?'.

Kotlin ofrece varias maneras de usar un valor anulable:

  • la prueba [if (x != null)] : en la rama donde la prueba es verdadera, el compilador sabe que [x] no es igual a [null], y lo trata como un valor de tipo [String] (y no [String?]). Esto se conoce como “smart cast” (conversión inteligente);
  • la llamada segura [x?.length]: si [x] es igual a [null], la expresión se evalúa como [null] en lugar de provocar un error; de lo contrario, se evalúa como [x.length]. Por lo tanto, el resultado es de tipo [Int?];
  • el operador Elvis [x ?: defaultValue]: se evalúa como [x] si [x] no es igual a [null], y como [defaultValue] en caso contrario (su nombre proviene del parecido del símbolo “?” con el peinado del cantante, visto de perfil). Suele combinarse con la llamada segura: [x?.length ?: 0];
  • la función **let**: ***[x?.let { ... \\}] ejecuta el bloque entre llaves solo si *[x] no es igual a *[null]*; dentro del bloque, el valor se llama [it] y es de un tipo no anulable. El bloque es una lambda**, concepto que estudiaremos en el Capítulo 7;
  • la aserción [x!!]: el programador afirma que [x] no es igual a [null]. Si es cierto, [x!!] es de tipo [String]; de lo contrario, se lanza una [NullPointerException] . Debe usarse lo menos posible: es un regreso deliberado al comportamiento de Java.

Los operadores ?, ?: y !! se tratan con más detalle en la sección “Operadores de nulos”. C# adoptó un enfoque similar con sus “tipos de referencia anulables” (nullable reference types, C# 8), en forma de advertencias; en Kotlin, son errores de compilación.

En la práctica, el error [NullPointerException] es raro en Kotlin. Ahora solo puede producirse en unos pocos casos: el uso de !!, una excepción lanzada explícitamente y, sobre todo, el uso de código Java. El compilador de Kotlin no sabe si un método de Java puede devolver [null]: por lo tanto, le asigna un “tipo de plataforma”, que se indica como [String!] en los mensajes del compilador (no puede escribirse en el código), y que puede usarse como un [String] o como un [String?]. La responsabilidad recae entonces en el programador. Cuando se sabe que un método de Java puede devolver [null], su resultado se almacena en una variable anulable ([val path: String? = System.getenv("X")]): el compilador retoma entonces sus verificaciones. (Los métodos de Java anotados como [@Nullable] o [@NonNull]—por ejemplo, con anotaciones del proyecto JSpecify— reciben un tipo de Kotlin específico, no un tipo de plataforma.)

¿Qué ocurre con las clases envoltorio y con [Optional]? Un [Int] se compila como [int], y un [Int?] como [java.lang.Integer], ya que solo una referencia puede ser de tipo [null]: las clases envoltorio están ahí, pero el compilador las gestiona por sí solo. La clase [Optional] sigue siendo utilizable, ya que es una clase de Java, pero es de poca utilidad en Kotlin: un [String?] dice lo mismo que un [Optional<String>], sin crear un objeto adicional, y los operadores ?. y ?: reemplazan a sus métodos [map] y [orElse]. Las funciones de la biblioteca de Kotlin que pueden no devolver nada devuelven [null]: [toIntOrNull()], [firstOrNull()], [readlnOrNull()]...

Encontraremos tipos anulables desde los primeros ejemplos, porque la función [readlnOrNull()], que lee una línea escrita en el teclado, devuelve [null] cuando ya no queda nada por leer (fin del flujo de entrada). El programa [Basics06.kt] es el siguiente:

// seguridad frente a nulos
package basics06

// una función que puede no devolver nada: el tipo de su resultado es String?
fun firstNameOf(name: String): String? = if (name == "dupont") "jean" else null

fun main() {
    // un String no puede ser null; un String? sí
    val firstName1: String? = firstNameOf("dupont")
    val firstName2: String? = firstNameOf("martin")
    println("firstName1=$firstName1, firstName2=$firstName2, firstName2 is null: ${firstName2 == null}")
    // después de la prueba, firstName1 es de tipo String: se puede usar su propiedad length
    if (firstName1 != null) {
        println("firstName1 has ${firstName1.length} characters")
    }
    // la llamada segura ?. devuelve null si el objeto es null
    println("lengths: ${firstName1?.length}, ${firstName2?.length}")
    // el operador Elvis ?: proporciona un valor de reemplazo
    println("firstName2: ${firstName2 ?: "unknown"}, length: ${firstName2?.length ?: 0}")
    // let: el bloque se ejecuta solo si el valor no es nulo; dentro, se llama it
    firstName1?.let { println("let: $it in upper case: ${it.uppercase()}") }
    firstName2?.let { println("this text is not displayed") }

    // un Int? se representa con un java.lang.Integer, un Int con un int
    val age: Int? = "23".toIntOrNull()
    val unknownAge: Int? = "twenty".toIntOrNull()
    println("age=$age, unknownAge=$unknownAge, (unknownAge ?: 0) + 1 = ${(unknownAge ?: 0) + 1}")

    // la aserción !!: "este valor no es nulo", de lo contrario NullPointerException
    println("firstName1!!.length=${firstName1!!.length}")
    try {
        println(firstName2!!.length)
    } catch (e: NullPointerException) {
        println("!! applied to null: ${e::class.qualifiedName}")
    }

    // un método de Java: el compilador no sabe si el resultado puede ser null
    val path = System.getenv("UNKNOWN_VARIABLE")
    println("path=$path, length: ${path?.length}")
    try {
        // aceptado por el compilador, pero NullPointerException en tiempo de ejecución
        println(path.length)
    } catch (e: NullPointerException) {
        println("path.length: ${e.message}")
    }

    // readlnOrNull devuelve null si el flujo de entrada está cerrado
    print("Type a line: ")
    val line = readlnOrNull()
    if (line == null) {
        println()
        println("No line: the input stream is closed")
    } else {
        println("You typed [$line]: ${line.length} character(s)")
    }
}

Resultados al ingresar texto por el teclado:

> gradlew -q run -Pmain=basics06.Basics06Kt
firstName1=jean, firstName2=null, firstName2 is null: true
firstName1 has 4 characters
lengths: 4, null
firstName2: unknown, length: 0
let: jean in upper case: JEAN
age=23, unknownAge=null, (unknownAge ?: 0) + 1 = 1
firstName1!!.length=4
!! applied to null: java.lang.NullPointerException
path=null, length: null
path.length: Cannot invoke "String.length()" because "path" is null
Type a line: hello
You typed [hello]: 5 character(s)

Resultados cuando el usuario presiona Ctrl-D (Ctrl-Z seguido de Enter en Windows), lo que cierra el flujo de entrada:

> gradlew -q run -Pmain=basics06.Basics06Kt
firstName1=jean, firstName2=null, firstName2 is null: true
firstName1 has 4 characters
lengths: 4, null
firstName2: unknown, length: 0
let: jean in upper case: JEAN
age=23, unknownAge=null, (unknownAge ?: 0) + 1 = 1
firstName1!!.length=4
!! applied to null: java.lang.NullPointerException
path=null, length: null
path.length: Cannot invoke "String.length()" because "path" is null
Type a line:
No line: the input stream is closed

Comentarios:

  • Línea 5: una función que devuelve un nombre de pila, o bien [null]. El tipo de su resultado, [String?], informa de ello a quienes la usan. La expresión [if (...) "jean" else null] es un [if] que devuelve un valor; volveremos sobre esto;
  • líneas 9–10: dos variables de tipo [String?]. [firstName2] es igual a [null]. El tipo podría haberse omitido: se habría inferido a partir del tipo del resultado de [firstNameOf];
  • línea 11: una plantilla muestra [null] para un valor nulo; el valor [null] se comprueba con el operador ==;
  • líneas 13–14: dentro del bloque [if], [firstName1] es de tipo [String]: su propiedad [length] (la longitud de la cadena) puede usarse con seguridad. Fuera del bloque, [firstName1.length] sería rechazado;
  • línea 17: la llamada segura. [firstName2?.length] es igual a [null];
  • línea 19: el operador Elvis. [firstName2 ?: "unknown"] es "unknown", y [firstName2?.length ?: 0] es 0;
  • líneas 21–22: la función [let]. El primer bloque se ejecuta con [it] igual a "jean"; el segundo no;
  • líneas 25–26: la función [toIntOrNull()] convierte una cadena en un entero y devuelve [null] si la cadena no representa un entero. El tipo [Int?] se compila como [java.lang.Integer];
  • Línea 27: no se pueden hacer cálculos con un [Int?]; [unknownAge + 1] sería rechazado. El operador Elvis devuelve un [Int]: 0 si [unknownAge] es igual a [null]. Hacer unboxing de un [Integer] nulo —una trampa clásica de Java— es, por lo tanto, imposible;
  • línea 30: la aserción !! aplicada a un valor no nulo: devuelve el valor, de tipo [String];
  • líneas 31–34: la aserción !! aplicada a *[null] lanza una *[NullPointerException]. La estructura [try / catch]*, que captura el error, se describe más adelante; aquí se muestra el nombre completo de la clase de la excepción. [NullPointerException]* es una clase de Java, a la que Kotlin se refiere con el mismo nombre;
  • línea 38: el método de Java [System.getenv] devuelve el valor de una variable de entorno del sistema, o [null] si no existe. Su resultado es del tipo de plataforma [String!]: [path] es, por lo tanto, de este tipo;
  • línea 39: cuando se usa como [String?], [path] se comporta correctamente;
  • línea 42: cuando se usa como [String], el compilador lo acepta, pero provoca una [NullPointerException] en tiempo de ejecución. El mensaje de la excepción (propiedad [message]), generado por la JVM, especifica exactamente qué expresión era [null]. Si hubiéramos escrito [val path: String? = System.getenv(...)], el compilador habría rechazado esa línea;
  • línea 48: la función [print] escribe en pantalla sin pasar a la línea siguiente; la entrada del usuario seguirá al mensaje;
  • línea 49: la función [readlnOrNull()] lee la línea escrita en el teclado. Devuelve un valor de tipo [String?]: [null] si el flujo de entrada está cerrado;
  • línea 50: se comprueba el valor [null];
  • línea 54: en la rama [else], [line] es de tipo [String]: [line.length] puede usarse con seguridad.

3.3.5. Conversiones entre números y cadenas

Conversión
Función
número -> cadena
[number.toString()], una plantilla como ["$number"], ["" + number], o un formato como ["%d".format(number)]
cadena -> int
[string.toInt()], [string.toIntOrNull()]
cadena -> Long
[string.toLong()], [string.toLongOrNull()]
cadena -> Double
[string.toDouble()], [string.toDoubleOrNull()]
cadena -> Float
[string.toFloat()], [string.toFloatOrNull()]
cadena -> BigDecimal
[string.toBigDecimal()], [string.toBigDecimalOrNull()]
cadena -> Boolean
[string.toBoolean()], [string.toBooleanStrictOrNull()]

Estas funciones de conversión forman parte de la biblioteca de Kotlin (paquete [kotlin.text]) y se llaman directamente sobre la propia cadena: ["10".toInt()] en lugar de la función de Java [Integer.parseInt("10")], que sigue siendo utilizable. Son funciones de extensión: funciones escritas fuera de la clase [String], pero que se llaman igual que sus métodos. Aprenderemos a escribirlas en el Capítulo 4.

Convertir una cadena en un número puede fallar si la cadena no representa un número válido. Una función como [toInt()] genera entonces un error llamado excepción—en este caso, de tipo [NumberFormatException]— que termina el programa si no se maneja. Este error puede manejarse con la siguiente cláusula [try / catch]:

1
2
3
4
5
6
try {
    call of the function likely to throw the exception
} catch (e: NumberFormatException) {
    handle the exception e
}
next statement

Si la función no lanza una excepción, la ejecución continúa con la instrucción siguiente; de lo contrario, pasa al cuerpo de la cláusula [catch] y luego a la instrucción siguiente. Volveremos sobre el manejo de excepciones en la sección dedicada a él.

Kotlin también ofrece, para cada conversión, una versión que no lanza excepción: [toIntOrNull()], [toDoubleOrNull()]... devuelven [null] si la conversión falla. Sus valores de retorno son anulables ([Int?], [Double?]...): por lo tanto, el compilador exige que se maneje el fallo. Combinadas con el operador Elvis, permiten escribir una conversión con un valor predeterminado en una sola línea: [input.toIntOrNull() ?: 0]. Java no tiene un equivalente; el curso de Java escribió su propio método, que devolvía un [OptionalInt].

Estas funciones aceptan un signo + o - inicial, pero no espacios ni separadores de miles: use la función [trim()] para eliminar los espacios iniciales y finales de una entrada antes de convertirla.

El programa [Basics07.kt] demuestra varias técnicas para convertir entre números y cadenas. La función [display] muestra en pantalla el valor de su parámetro:

// conversiones entre números y cadenas de caracteres
package basics07

import java.text.NumberFormat
import java.util.Locale

fun main() {
    // datos
    val i = 10
    val l = 100000L
    val f = 45.78F
    val d = -14.98

    // número -> cadena
    display(i.toString())
    display(l.toString())
    display("$f")
    display("" + d)

    // booleano -> cadena
    val b = false
    display(b.toString())

    // cadena -> Int
    var i1 = "10".toInt()
    display(i1.toString())
    try {
        i1 = "10.67".toInt()
        display(i1.toString())
    } catch (e: NumberFormatException) {
        display("Error: ${e.message}")
    }

    // cadena -> Long
    var l1 = "100".toLong()
    display(l1.toString())
    try {
        l1 = "10.675".toLong()
        display(l1.toString())
    } catch (e: NumberFormatException) {
        display("Error: ${e.message}")
    }

    // cadena -> Double: el separador decimal siempre es el punto
    var d1 = "100.87".toDouble()
    display(d1.toString())
    try {
        d1 = "abcd".toDouble()
        display(d1.toString())
    } catch (e: NumberFormatException) {
        display("Error: ${e.message}")
    }

    // cadena -> Float
    var f1 = "100.87".toFloat()
    display(f1.toString())
    try {
        f1 = "100,87".toFloat()
        display(f1.toString())
    } catch (e: NumberFormatException) {
        display("Error: ${e.message}")
    }

    // cadena -> BigDecimal
    val m1 = "100.87".toBigDecimal()
    display(m1.toString())

    // cadena -> Boolean
    display("${"true".toBoolean()} ${"yes".toBoolean()} ${"yes".toBooleanStrictOrNull()}")

    // conversiones sin excepciones: las funciones xxxOrNull devuelven null en caso de fallo
    val i2 = "123".toIntOrNull()
    if (i2 != null) {
        display("\"123\".toIntOrNull() succeeded: $i2")
    }
    val i3 = "12x".toIntOrNull()
    if (i3 == null) {
        display("\"12x\".toIntOrNull() failed")
    }
    display("with a default value: ${"12x".toIntOrNull() ?: -1}")
    // no se aceptan espacios: se eliminan con trim()
    display("[ 42 ] : ${" 42 ".toIntOrNull()}, ${" 42 ".trim().toIntOrNull()}")

    // el idioma del usuario (la "configuración regional") solo interviene en los formatos
    display("Current locale: ${Locale.getDefault().toLanguageTag()}")
    display("%.2f".format(d1))
    display("%.2f".format(Locale.ROOT, d1))
    // lectura de un número escrito a la manera francesa: la clase NumberFormat de Java
    // parse puede lanzar una ParseException: Kotlin no nos obliga a manejarla
    val number = NumberFormat.getInstance(Locale.FRANCE).parse("100,87")
    display("NumberFormat: ${number.toDouble()}")
}

// una función que muestra su parámetro
fun display(s: String) {
    println("S=$s")
}

Resultados:

> gradlew -q run -Pmain=basics07.Basics07Kt
S=10
S=100000
S=45.78
S=-14.98
S=false
S=10
S=Error: For input string: "10.67"
S=100
S=Error: For input string: "10.675"
S=100.87
S=Error: For input string: "abcd"
S=100.87
S=Error: For input string: "100,87"
S=100.87
S=true false null
S="123".toIntOrNull() succeeded: 123
S="12x".toIntOrNull() failed
S=with a default value: -1
S=[ 42 ] : null, 42
S=Current locale: fr-FR
S=100,87
S=100.87
S=NumberFormat: 100.87

Comentarios:

  • líneas 9–12: los datos que se van a convertir;
  • líneas 15–18: cuatro maneras de convertir un número en cadena. La tercera usa una plantilla, y la última concatena una cadena vacía con el número. La plantilla es el método más común en Kotlin;
  • línea 22: un booleano se muestra como [true] o [false];
  • líneas 25–31: manejamos la excepción que [toInt()] puede lanzar. La variable [i1] se declara con [var] porque recibe un nuevo valor en [try]. [e.message] es el mensaje de error asociado a la excepción [e] (el método de Java [getMessage()], visto en Kotlin como una propiedad). Son los mensajes de los métodos de Java llamados por las funciones de Kotlin: están en inglés;
  • línea 45: [toDouble()] siempre espera un punto decimal, sea cual sea el idioma del usuario: la cadena "100.87" se interpreta de la misma manera en todas las máquinas. Esta es la forma correcta de leer números desde archivos o en intercambios entre programas;
  • línea 58: en consecuencia, se rechaza la coma decimal;
  • línea 65: conversión de una cadena a [BigDecimal]; esta también espera un punto decimal. Equivale a [BigDecimal("100.87")];
  • línea 69: [toBoolean()] devuelve [true] para la cadena "true" (sin distinguir mayúsculas de minúsculas) y [false] para cualquier otra cadena, incluida "yes". [toBooleanStrictOrNull()] acepta solo “true” y “false”, y devuelve [null] para todo lo demás;
  • Líneas 72–78: conversiones sin excepción. [i2] e [i3] son del mismo tipo que [Int?]; después de la prueba [i2 != null], [i2] puede usarse como un [Int]. En una cadena, una comilla se escribe \";
  • línea 80: una conversión con un valor predeterminado, mediante el operador Elvis. La plantilla contiene una cadena, "12x", que a su vez está entre comillas: esto se permite dentro de las llaves;
  • línea 82: " 42 " no se convierte; después de [trim()], sí se convierte;
  • línea 85: [Locale.getDefault()] devuelve la configuración regional (locale) del programa —es decir, el idioma y el país del usuario, obtenidos de la configuración del sistema: aquí, fr-FR;
  • línea 86: un formato usa la configuración regional actual: el número real se escribe con coma decimal;
  • línea 87: la función [format] acepta una configuración regional (locale) como primer parámetro. [Locale.ROOT] es una configuración regional neutra que usa el punto como separador decimal, sin importar la máquina. Se utiliza para escribir números con formato en archivos o en intercambios entre programas, que no deben depender del idioma del usuario;
  • línea 90: para leer un número escrito según las convenciones francesas, se usa un objeto [NumberFormat] (del paquete [java.text] del JDK) obtenido para la configuración regional [Locale.FRANCE]. Su método [parse] devuelve un objeto [Number] y puede lanzar una excepción [ParseException]. En Java, esta es una excepción verificada (checked): el compilador exige que se maneje. Kotlin no tiene excepciones verificadas: el compilador deja al programador la decisión de manejar o no la excepción. Volveremos sobre este tema en la sección sobre excepciones;
  • línea 91: [toDouble()] convierte [Number] en [Double];
  • líneas 95–96: una función de nivel superior. Las funciones pueden escribirse en cualquier orden, antes o después de [main]. No devuelve ningún resultado: se omite el tipo de retorno (en realidad es de tipo [Unit], el equivalente de [void] en Java).

Observe que las funciones [toInt()], [toDouble()]... y [toString()] ignoran el idioma del usuario (punto decimal), mientras que los formatos y la clase [NumberFormat] sí lo respetan. Un programa que lee números siempre debe saber qué convenciones se usaron para escribirlos.

3.3.6. Arreglos de datos

Un arreglo de Kotlin es un objeto que permite agrupar datos del mismo tipo bajo un único identificador. Kotlin distingue dos tipos de arreglos:

  • el tipo genérico [Array<T>], un arreglo de elementos de tipo [T]: [Array<String>] es un arreglo de cadenas. Corresponde al arreglo de objetos [T[]] de Java ([String[]]);
  • tipos especializados para los tipos básicos: [IntArray], [LongArray], [DoubleArray], [BooleanArray], [CharArray]... Un [IntArray] corresponde al arreglo Java [int[]]: sus elementos son valores primitivos, dispuestos uno junto a otro en la memoria. Se podría escribir [Array<Int>], pero sería un arreglo de objetos [Integer] ([Integer[]]), que ocupa más espacio y es más lento: para los números se prefieren los arreglos especializados.

Hay varias maneras de crear un arreglo:

1
2
3
4
5
val t1 = arrayOf("a", "b", "c")         // initialized Array<String>
val t2 = intArrayOf(0, 10, 20, 30)      // initialized IntArray
val t3 = IntArray(n)                    // n integers equal to 0
val t4 = Array(n) { i -> value }        // n elements, computed from their index
val t5 = arrayOfNulls<String>(n)        // Array<String?> of n elements equal to null

Kotlin no tiene un operador [new] ni la sintaxis [{0, 10, 20\}] para crear un arreglo: todo se hace mediante funciones ([arrayOf], [intArrayOf]...) o constructores ([IntArray(n)], [Array(n) { ... \}]). Un [IntArray(n)] contiene n ceros, mientras que un [BooleanArray(n)] contiene n valores [false]. En cambio, no existe un [Array<String>(n)] cuyos elementos serían [null]: esto violaría la seguridad frente a nulos (null safety), ya que los elementos son de tipo [String]. Hay que especificar el valor de cada elemento o solicitar explícitamente un arreglo de elementos que admiten nulos mediante [arrayOfNulls<String>(n)], de tipo [Array<String?>].

El número de elementos de un arreglo es su propiedad [size] (el campo [length] de Java). La sintaxis [array[i]] hace referencia al dato número i, donde i pertenece al intervalo [0, size-1]. Cualquier referencia al dato [array[i]] donde i no esté en este intervalo provoca una excepción [ArrayIndexOutOfBoundsException]. La propiedad [indices] es el rango de índices válidos (de 0 a size-1), y [lastIndex] es el último índice (size-1). Un arreglo no puede cambiar de tamaño después de crearse: para una colección que crece se usa una lista (capítulo 5). Una variable [val] que hace referencia a un arreglo no puede hacer referencia a otro arreglo, pero los elementos del arreglo siguen siendo modificables.

Kotlin tampoco tiene verdaderos arreglos bidimensionales: un arreglo con dos índices es un arreglo de arreglos, por ejemplo, un [Array<DoubleArray>]. La sintaxis [array[i][j]] hace referencia al elemento j de la fila i. [array.size] es el número de filas, y [array[i].size] es el número de elementos de la fila i. Como cada fila es un arreglo independiente, las filas pueden tener longitudes distintas (esto se conoce como “arreglo escalonado”).

La biblioteca de Kotlin ofrece una amplia gama de funciones para arreglos que reemplazan los métodos de la clase [java.util.Arrays] y van mucho más allá de ellos: [contentToString()], [contentDeepToString()], [contentEquals()], [first()], [last()], [getOrNull(i)], [copyOf()], [copyOfRange(start, end)], [sliceArray(range)], [sort()], [sorted()], [fill()], [sum()], [max()], [average()], [contains()] (que se escribe con el operador [in])... En su mayoría, son las mismas que las de las listas, que examinaremos en el capítulo 5.

El programa [Basics08.kt] combina estos diferentes arreglos:

// arreglos
package basics08

fun main() {
    // un arreglo inicializado de enteros: un IntArray (un int[] de Java)
    val integers = intArrayOf(0, 10, 20, 30)
    for (i in integers.indices) {
        println("integers[$i]=${integers[i]}")
    }

    // un arreglo de 2 dimensiones: un arreglo de arreglos de la misma longitud
    val reals = arrayOf(doubleArrayOf(0.5, 1.7), doubleArrayOf(8.4, -6.0))
    for (i in reals.indices) {
        for (j in reals[i].indices) {
            println("reals[$i][$j]=${reals[i][j]}")
        }
    }
    println("reals=${reals.contentDeepToString()}")

    // un arreglo de arreglos de longitudes diferentes (arreglo irregular)
    // Array(n) { i -> ... } calcula el valor de cada elemento a partir de su índice
    val names = Array(3) { i -> Array(i + 1) { j -> "name$i$j" } }
    for (i in names.indices) {
        for (j in names[i].indices) {
            println("names[$i][$j]=${names[i][j]}")
        }
    }

    // arreglos creados sin valores iniciales
    val flags = BooleanArray(3)
    val strings = arrayOfNulls<String>(2)
    println("flags[0]=${flags[0]}, strings[0] is null: ${strings[0] == null}")

    val values = intArrayOf(0, 10, 20, 30, 40)
    // contentToString construye una cadena con los elementos del arreglo
    println("values=${values.contentToString()}, size=${values.size}, lastIndex=${values.lastIndex}")
    // el primero, el último y el penúltimo elemento
    println("first=${values.first()}, last=${values.last()}")
    println("second-to-last=${values[values.size - 2]}, ${values[values.lastIndex - 1]}")
    // una parte del arreglo: los elementos en los índices 1 y 2 (el límite final se excluye)
    val extract = values.copyOfRange(1, 3)
    println("copyOfRange(1, 3)=${extract.contentToString()}")
    // los elementos desde el índice 2 hasta lastIndex (rango cerrado)
    val end = values.sliceArray(2..values.lastIndex)
    println("sliceArray(2..lastIndex)=${end.contentToString()}")
    // el extracto es una copia: el arreglo original no se modifica
    extract[0] = 100
    println("extract[0]=${extract[0]}, values[1]=${values[1]}")
    // algunas funciones de la biblioteca de Kotlin
    println("sum=${values.sum()}, max=${values.max()}, average=${values.average()}")
    println("20 in values: ${20 in values}, 25 in values: ${25 in values}")

    // un arreglo de objetos: Array<String>
    val friends = arrayOf("paul", "hélène", "jacques")
    println("first friend=${friends.first()}, last friend=${friends.last()}, friends.getOrNull(5)=${friends.getOrNull(5)}")
    // un índice fuera de los límites del arreglo
    try {
        println(friends[3])
    } catch (e: ArrayIndexOutOfBoundsException) {
        println("friends[3]: ${e.message}")
    }
}

Resultados:

> gradlew -q run -Pmain=basics08.Basics08Kt
integers[0]=0
integers[1]=10
integers[2]=20
integers[3]=30
reals[0][0]=0.5
reals[0][1]=1.7
reals[1][0]=8.4
reals[1][1]=-6.0
reals=[[0.5, 1.7], [8.4, -6.0]]
names[0][0]=name00
names[1][0]=name10
names[1][1]=name11
names[2][0]=name20
names[2][1]=name21
names[2][2]=name22
flags[0]=false, strings[0] is null: true
values=[0, 10, 20, 30, 40], size=5, lastIndex=4
first=0, last=40
second-to-last=30, 30
copyOfRange(1, 3)=[10, 20]
sliceArray(2..lastIndex)=[20, 30, 40]
extract[0]=100, values[1]=10
sum=100, max=40, average=20.0
20 in values: true, 25 in values: false
first friend=paul, last friend=jacques, friends.getOrNull(5)=null
friends[3]: Index 3 out of bounds for length 3

Comentarios:

  • línea 6: un arreglo de enteros inicializado, de tipo [IntArray];
  • línea 7: un bucle de tipo [for] recorre los índices del arreglo, de 0 a [integers.lastIndex]. El bucle de tipo [for] se presenta más adelante;
  • línea 8: en una plantilla, [$i] es el valor del índice y [${integers[i]\}] es el valor del elemento. Las llaves son obligatorias para la expresión [integers[i]]; el corchete que sigue a [[$i] no las requiere, ya que no puede formar parte de un nombre de variable;
  • línea 12: un arreglo bidimensional (2 filas, 2 columnas) de tipo [Array<DoubleArray>]. Debe escribirse -6.0 y no -6: la función [doubleArrayOf] espera [Double], y Kotlin no convierte el entero -6 en un número de punto flotante (Java sí lo hace);
  • líneas 13–14: [reals.indices] recorre las filas, [reals[i].indices] recorre las columnas de la fila i;
  • línea 18: [contentDeepToString()] muestra un arreglo de arreglos;
  • línea 22: un arreglo escalonado de 3 filas. El constructor [Array(3) { i -> ... \}] crea un arreglo de 3 elementos y calcula el valor de cada uno ejecutando el bloque entre llaves con el índice [i] del elemento. Aquí, cada elemento es a su vez un arreglo de cadenas ([i + 1]), cuyo elemento con índice [j] es "name" seguido de i y j. El bloque entre llaves es una lambda (capítulo 7); por ahora basta con leerlo como “para el índice i, el valor es...”. En Java, esto requería tres pasos: crear el arreglo de filas, crear cada fila y luego llenar los elementos;
  • línea 30: un arreglo de 3 booleanos, todos ellos [false];
  • línea 31: un arreglo de 2 cadenas que admiten nulos, todas ellas [null];
  • línea 36: la función [contentToString()] construye una cadena a partir de los elementos del arreglo. Mostrar el arreglo directamente ([println(values)]) produciría, como en Java, un texto como [I@6328d34a (el tipo del arreglo y un código numérico), en lugar de su contenido;
  • líneas 38–39: el primer elemento, el último y el penúltimo. Las funciones [first()] y [last()] reemplazan las expresiones [values[0]] y [values[values.size - 1]]. Kotlin no tiene un índice contado desde el final del arreglo (el equivalente en C# de [^1]);
  • línea 41: los elementos de los índices 1 y 2. Como con [Arrays.copyOfRange] en Java, el límite final queda excluido;
  • línea 44: los elementos de los índices 2 a [lastIndex]. [2..values.lastIndex] es un rango: el conjunto de los enteros de 2 a 4, ambos incluidos. La función [sliceArray] devuelve un nuevo arreglo formado por los elementos cuyos índices pertenecen al rango. Los rangos se presentan con el bucle [for];
  • líneas 47–48: [copyOfRange] crea una copia; modificar [extract] no modifica [values];
  • línea 50: la suma, el máximo y el promedio de los elementos. El promedio es un [Double];
  • línea 51: el operador [in] verifica si un valor está presente en el arreglo;
  • línea 54: un arreglo de objetos, de tipo [Array<String>];
  • línea 55: [friends.getOrNull(5)] devuelve [null] en lugar de lanzar una excepción cuando el índice está fuera de los límites;
  • líneas 58–60: el índice 3 no existe: se lanza una [ArrayIndexOutOfBoundsException] con un mensaje que indica el índice incorrecto y el tamaño del arreglo.

3.4. Instrucciones básicas de Kotlin

Hay dos tipos:

  • instrucciones elementales ejecutadas por la computadora;
  • instrucciones que controlan el flujo del programa.

Las instrucciones básicas se entienden mejor al considerar la estructura de una microcomputadora y sus periféricos:

Image

  • 1: lectura de información desde el teclado;
  • 2: procesamiento de información;
  • 3: escritura de información en la pantalla.

3.4.1. Escritura en la pantalla

Existen varias instrucciones para escribir en la pantalla:

1
2
3
4
println(expression)
print(expression)
System.out.println(expression)
System.err.println(expression)

donde [expression] es cualquier dato que pueda convertirse en una cadena de caracteres para mostrarse en la pantalla. Todos los objetos tienen un método [toString()] que se utiliza para realizar esta conversión. La función [println] escribe el valor y luego pasa a la línea siguiente; la función [print] hace lo mismo sin pasar a la línea siguiente; [println()], sin ningún parámetro, simplemente pasa a la línea siguiente. Para una salida con formato, se usa [println("format".format(value1, ...))], o bien el método de Java [System.out.printf(format, value1, ...)].

Las funciones de Kotlin [println] y [print] (del paquete [kotlin.io]) escriben en el flujo de Java [System.out]. La clase [System] da acceso a dos flujos de escritura mediante sus campos estáticos [out] y [err], que son de tipo [PrintStream]:

  • [System.out.println()] escribe en el flujo [out], la salida estándar, que normalmente está asociada con la pantalla;
  • [System.err.println()] escribe en el flujo [err], la salida de errores, que normalmente también está asociada con la pantalla.

La biblioteca de Kotlin no tiene una función para escribir en la salida de errores: se usa directamente [System.err.println]. Los flujos [out] y [err] pueden redirigirse a archivos en tiempo de ejecución, como veremos en breve.

3.4.2. Lectura de datos ingresados desde el teclado

El flujo de datos del teclado está representado por el campo de Java [System.in], que es de tipo [InputStream]. Se trata de un flujo de bytes, poco cómodo de usar directamente. La biblioteca de Kotlin proporciona dos funciones que leen una línea de texto de este flujo:

val line: String = readln()
val line: String? = readlnOrNull()

La línea escrita en el teclado, sin el carácter de fin de línea, se almacena en la variable [line] y luego el programa puede procesarla. Las dos funciones se diferencian únicamente en su comportamiento al final del flujo de entrada (cuando el usuario presiona Ctrl-D, o Ctrl-Z seguido de Enter en Windows, o cuando se agota el archivo redirigido al flujo de entrada):

  • [readln()] lanza entonces una excepción [ReadAfterEOFException]; por lo tanto, siempre devuelve una cadena de tipo [String];
  • [readlnOrNull()] devuelve entonces [null]; su resultado es de tipo [String?], lo que obliga a manejar este caso, como lo hizo el programa [Basics06.kt].

Estas funciones no muestran un indicador (prompt): este se especifica de antemano con [print]. En programas más antiguos también puede encontrarse la función [readLine()], que se comporta como [readlnOrNull()], así como las clases de Java [BufferedReader] y [Scanner], que aún pueden utilizarse. El flujo [System.in] puede redirigirse a un archivo, al igual que los flujos [out] y [err]. Por último, cabe mencionar la clase de Java [Console], obtenida a partir de [System.console()], cuyo método [readPassword] lee una contraseña sin mostrarla.

3.4.3. Ejemplo de entrada/salida

El programa [Basics09.kt] ilustra las operaciones de entrada/salida con teclado y pantalla:

// entrada/salida por teclado y pantalla
package basics09

fun main() {
    // escritura en el flujo System.out
    val obj = Any()
    println(obj)

    // escritura en el flujo System.err
    val i = 10
    System.err.println("i=$i")
    System.err.printf("i=%d%n", i)

    // lectura de una línea escrita en el teclado, después de mostrar un mensaje
    print("Type a line: ")
    val line = readln()
    println("line=$line")
}

Resultados:

1
2
3
4
5
6
> gradlew -q run -Pmain=basics09.Basics09Kt
java.lang.Object@2b2fa4f7
i=10
i=10
Type a line: here I am
line=here I am

Comentarios:

  • línea 6: [obj] es una referencia a un objeto de la clase [Any], la clase raíz de todas las clases de Kotlin ([Object] en Java). El objeto se crea llamando al constructor [Any()], sin [new];
  • línea 7: [obj] se imprime en la pantalla. Se llama al método [obj.toString()] para obtener el texto que se mostrará;
  • línea 11: [err] se escribe en el flujo;
  • línea 12: lo mismo, pero con un formato. El primer parámetro, "i=%d%n," es el formato de visualización; los demás parámetros son los valores que se mostrarán: %d se reemplaza por el valor de [i], y %n por el carácter de fin de línea del sistema (\r\n en Windows, \n en Linux y macOS);
  • línea 15: se muestra un indicador (prompt) sin pasar a la línea siguiente;
  • línea 16: lee la línea escrita en el teclado. [line] es de tipo [String].

En los resultados:

  • línea 2: la salida generada por la línea 7 del código. El método [toString()] de la clase [Any] devuelve el nombre completo de la clase del objeto, seguido del carácter @ y de un código numérico hexadecimal (su “código hash”), que puede variar de una ejecución o máquina a otra. Se observa que la clase de Kotlin *[Any]* es, en tiempo de ejecución, efectivamente la clase *[java.lang.Object]*. Las clases generalmente redefinen este método para mostrar algo más útil, como haremos en el capítulo 4;
  • líneas 3–4: las dos escrituras en el flujo [err] aparecen en la pantalla igual que las del flujo [out].

Si el usuario cierra el flujo de entrada en lugar de escribir una línea, [readln()] lanza una excepción que termina el programa:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=basics09.Basics09Kt
java.lang.Object@2b2fa4f7
i=10
i=10
Type a line: Exception in thread "main" kotlin.io.ReadAfterEOFException: EOF has already been reached
    at kotlin.io.ConsoleKt.readln(Console.kt:152)
    at basics09.Basics09Kt.main(Basics09.kt:16)
    at basics09.Basics09Kt.main(Basics09.kt)

Al mensaje de la excepción le sigue la pila de llamadas (“stack trace”): la lista de funciones que se estaban ejecutando en el momento del error, con la más reciente en la parte superior, junto con el archivo y el número de línea de cada una. Muestra que la función [readln] (archivo [Console.kt] de la biblioteca de Kotlin) fue llamada en la línea 16 del archivo [Basics09.kt], a través del método [main] de la clase [Basics09Kt], que a su vez fue llamado por el método [main(String[])] generado por el compilador. (Con [gradlew run], Gradle también informa que la tarea [run] falló; sus mensajes no se reproducen aquí.)

3.4.4. Redirección de entrada/salida

Windows, Linux y macOS reconocen tres dispositivos estándar:

  • el dispositivo de entrada estándar, que por defecto corresponde al teclado y está numerado 0;
  • el dispositivo de salida estándar, que por defecto corresponde a la pantalla y está numerado 1;
  • el dispositivo de error estándar, que por defecto corresponde a la pantalla y está numerado 2.

En la JVM, el flujo de escritura [System.out] (asociado con las funciones [println] y [print]) escribe en el dispositivo 1, el flujo de escritura [System.err] escribe en el dispositivo 2, y el flujo de lectura [System.in] (asociado con las funciones [readln] y [readlnOrNull]) lee datos del dispositivo 0.

Cuando se ejecuta un programa en una ventana de comandos, se puede especificar cuáles serán los dispositivos 0, 1 y 2 del programa en ejecución. Después de los argumentos del programa, se pueden redirigir los dispositivos estándar de entrada/salida a archivos:

Redirección
Significado
0<in.txt o <in.txt
El flujo de entrada estándar n.º 0 se redirige al archivo in.txt. En el programa, el flujo [System.in] leerá entonces sus datos del archivo in.txt
1>out.txt o >out.txt
redirige la salida n.º 1 al archivo out.txt. En el programa, el flujo [System.out] escribirá entonces sus datos en el archivo out.txt
1>>out.txt o >>out.txt
Igual que lo anterior, pero los datos escritos se agregan al contenido actual del archivo out.txt
2>err.txt
Redirige la salida n.º 2 al archivo err.txt. En el programa, el flujo [System.err] escribirá entonces sus datos en el archivo err.txt
2>>err.txt
Igual que lo anterior, pero los datos escritos se agregan al contenido actual del archivo err.txt
1>out.txt 2>err.txt
Los dispositivos 1 y 2 se redirigen ambos a archivos

Observe que, para redirigir los flujos de entrada/salida de un programa a archivos, no es necesario modificar el programa: el sistema operativo determina la naturaleza de los dispositivos 0, 1 y 2. Considere el siguiente programa, [Basics10.kt]:

// redirecciones de los flujos de entrada/salida
package basics10

fun main() {
    // lectura del flujo System.in
    val data = readln()
    // escritura en el flujo System.out
    println("writing to the out stream: $data")
    // escritura en el flujo System.err
    System.err.println("writing to the err stream: $data")
}

Las redirecciones se aplican al programa iniciado por el comando escrito en el indicador de comandos. Con ***[gradlew run]***, ese programa es el propio Gradle, que luego transmite los flujos al programa Kotlin: la redirección suele funcionar, pero los archivos también pueden recibir mensajes de Gradle (advertencias, errores de compilación, etc.). Para observar el comportamiento del programa por sí solo, conviene ejecutarlo fuera de Gradle. Como vimos en el capítulo 2, la tarea [installDist] prepara una versión instalable del proyecto en la carpeta [build/install/basics] (cuyo nombre, [basics], lo define el archivo [settings.gradle.kts]): una carpeta llamada [lib], que contiene el archivo de clases del proyecto y la biblioteca estándar de Kotlin, y una carpeta llamada [bin], que contiene los scripts de inicio [basics] (Linux, macOS) y [basics.bat] (Windows). El script inicia la clase especificada por el archivo [build.gradle.kts] cuando se crea; por lo tanto, el programa se selecciona mediante el comando [installDist]:

> gradlew -q installDist -Pmain=basics10.Basics10Kt

Esta es una sesión en un terminal de Linux (bash), en la carpeta del proyecto:

> echo test > in.txt
> cat in.txt
test
> build/install/basics/bin/basics < in.txt > out.txt 2> err.txt
> cat out.txt
writing to the out stream: test
> cat err.txt
writing to the err stream: test
> build/install/basics/bin/basics < in.txt 2> err.txt
writing to the out stream: test
> build/install/basics/bin/basics < in.txt > out.txt
writing to the err stream: test

Comentarios:

  • línea 1: insertamos la cadena "test" en el archivo in.txt;
  • línea 2: se muestra el contenido del archivo in.txt para verificarlo;
  • línea 4: se ejecuta el programa. El flujo [System.in] se redirige al archivo in.txt, el flujo [System.out] al archivo out.txt, y el flujo [System.err] al archivo err.txt. La ejecución no produce ninguna salida;
  • líneas 5–6: el contenido del archivo out.txt muestra que se leyó el archivo in.txt y que la escritura en el flujo [out] se redirigió a out.txt;
  • líneas 7–8: verificación similar para el archivo err.txt;
  • líneas 9–10: solo se redirige el flujo [err]: la pantalla muestra únicamente la operación de escritura en el flujo [out];
  • líneas 11–12: solo se redirige el flujo [out]: la pantalla muestra únicamente la operación de escritura en el flujo [err].

Es evidente que los flujos [out] y [err] no escriben en los mismos dispositivos, ya que pueden redirigirse por separado. El flujo [err] está destinado a los mensajes de error: esto permite redirigir la salida de un programa a un archivo y seguir viendo sus mensajes de error en la pantalla.

Los operadores >, >> y 2> se escriben igual en el símbolo del sistema de Windows ([cmd]), en PowerShell y en bash. El operador < es reconocido por [cmd] y bash, pero no por PowerShell, que lo reserva para uso futuro: en PowerShell, un archivo se envía a la entrada estándar de un programa mediante una tubería (|). Los siguientes comandos, que se presentan con fines ilustrativos (no se ejecutaron para este curso), hacen en Windows lo que hace la sesión de bash anterior:

rem Windows command prompt (cmd)
echo test>in.txt
build\install\basics\bin\basics <in.txt >out.txt 2>err.txt
type out.txt
type err.txt

# PowerShell
"test" > in.txt
Get-Content in.txt | build\install\basics\bin\basics > out.txt 2> err.txt
Get-Content out.txt
Get-Content err.txt

3.4.5. Asignación del valor de una expresión a una variable

Aquí nos interesa la operación [variable = expression]. La expresión puede ser aritmética, relacional, booleana, de cadena, etc.

3.4.5.1. Interpretación de la operación de asignación

La operación [variable = expression] se desarrolla de la siguiente manera:

  • Se evalúa el lado derecho de la asignación: el resultado es un valor V;
  • el valor V se asigna a la variable.

En Java, al igual que en C y C#, una asignación es en sí misma una expresión, cuyo valor es V: por lo tanto, se puede escribir [V1 = V2 = expression], que asigna el valor de la expresión a V2 y luego a V1, o [if ((n = read()) > 0)], que asigna y evalúa al mismo tiempo. En Kotlin, la asignación es una instrucción, no una expresión: no tiene valor y no puede aparecer donde se espera un valor. Por lo tanto, el compilador rechaza:

1
2
3
var v2 = 0
val v1 = (v2 = 7 * 6)
error: only expressions are allowed in this context.

Las asignaciones múltiples como [V1 = V2 = expression] se rechazan por la misma razón: implican escribir dos asignaciones. Esta decisión elimina una fuente común de errores en C y Java: la confusión entre el operador de asignación = y el operador de comparación == en una prueba como [if (x = 0)] resulta imposible.

3.4.5.2. Expresiones aritméticas

Los operadores utilizados en las expresiones aritméticas son los siguientes:

Operador
Descripción
+
suma
-
resta
*
multiplicación
/
división: el resultado es el cociente exacto si al menos uno de los operandos es un número real. Si ambos operandos son enteros, el resultado es el cociente entero. Así, 5/2 es igual a 2 y 5.0/2 es igual a 2.5
%
resto de la división, sea cual sea el tipo de los operandos. El resto tiene el mismo signo que el dividendo: -5 % 2 es igual a -1. El operador % es otra notación de la función [rem] (“remainder”): [a % b] equivale a [a.rem(b)]. La función [mod] devuelve el resto en el sentido matemático, con el signo del divisor: [(-5).mod(2)] es igual a 1

En Kotlin, todos estos operadores son, en realidad, formas alternativas de escribir funciones: [a + b] equivale a [a.plus(b)], [a - b] a [a.minus(b)], [a * b] equivale a [a.times(b)], y [a / b] equivale a [a.div(b)]. Por supuesto, el compilador traduce estas operaciones sobre los tipos básicos en instrucciones aritméticas de la JVM, sin ninguna llamada a funciones. Sin embargo, este mecanismo permite dotar a otras clases de estos operadores (sobrecarga de operadores, capítulo 4); la biblioteca de Kotlin lo ha hecho, en particular, para la clase Java [BigDecimal].

Existen diversas funciones matemáticas. Kotlin las agrupa en el paquete [kotlin.math], que debe importarse ([import kotlin.math.*] o [import kotlin.math.sqrt]...). Estas son algunas de ellas:

Función
Descripción
[sqrt(x)]
raíz cuadrada
[cos(x)], [sin(x)], [tan(x)]
coseno, seno, tangente (ángulo en radianes)
[x.pow(y)]
x elevado a la potencia y (y es un número real o un entero)
[exp(x)]
exponencial
[ln(x)], [log10(x)], [log(x, base)]
logaritmo natural, logaritmo decimal, logaritmo en cualquier base
[abs(x)] o [x.absoluteValue], [max(x, y)], [min(x, y)]
valor absoluto, máximo, mínimo (para los tipos Int, Long, Float, Double)
[floor(x)], [ceil(x)], [truncate(x)]
parte entera inferior, parte entera superior, truncamiento hacia cero
[x.roundToInt()], [x.roundToLong()]
redondeado al entero más cercano, con los valores intermedios redondeados hacia arriba
[round(x)]
redondea al entero más cercano, redondeando los valores intermedios al número par más cercano (resultado real)
[x.coerceIn(min, max)]
valor ajustado al intervalo [min, max]
[PI], [E]
las constantes π y e

Son funciones de alto nivel (o, como [pow] y [roundToInt], funciones de extensión que se llaman sobre el propio número): se llaman sin prefijo. Así, escribimos:

    val y = 4.0
    val x = sqrt(y)

Los métodos estáticos de la clase Java [Math] ([Math.sqrt(y)], [Math.floorMod(-5, 2)]...) aún pueden utilizarse sin importarlos, ya que [Math] pertenece al paquete [java.lang]. La descripción completa del paquete [kotlin.math] se encuentra en la documentación en línea de Kotlin, en kotlinlang.org/api/core/kotlin-stdlib/kotlin.math/.

Los números reales de tipo [Double] se almacenan en formato binario: la mayoría de los números decimales, como 0.1, solo se aproximan. Esto carece de importancia en los cálculos científicos, pero es inaceptable para montos de dinero. La clase [BigDecimal] (del paquete [java.math] del JDK), en cambio, representa un número decimal de forma exacta, con tantos dígitos como sea necesario. En Java, los cálculos se realizan con los métodos [add], [subtract], [multiply], [divide]... En Kotlin, estos métodos siguen disponibles, pero la biblioteca estándar añade a la clase los operadores +, -, *, /, % y el - unario: se escribe [a + b] en lugar de [a.add(b)]. También añade las funciones de conversión ["0.1".toBigDecimal()] y [3.toBigDecimal()]. Un [BigDecimal] es inmutable: una operación no modifica el objeto al que se aplica; en su lugar, devuelve un objeto nuevo.

El programa [Basics11.kt] es el siguiente:

// expresiones aritméticas
package basics11

import java.math.BigDecimal
import java.math.MathContext
import java.math.RoundingMode
import kotlin.math.*

fun main() {
    // división entera y división real
    println("5 / 2 = ${5 / 2}, 5.0 / 2 = ${5.0 / 2}, 5 / 2.0 = ${5 / 2.0}")
    // resto de la división: el operador % (función rem) y la función mod
    println("5 % 2 = ${5 % 2}, -5 % 2 = ${-5 % 2}, 5.5 % 2 = ${5.5 % 2}")
    println("(-5).rem(2) = ${(-5).rem(2)}, (-5).mod(2) = ${(-5).mod(2)}")
    // división real entre cero: sin error, infinito o NaN (Not a Number)
    val zero = 0.0
    println("1 / 0.0 = ${1 / zero}, 0 / 0.0 = ${0 / zero}")
    // división entera entre cero: una excepción
    val integerZero = "0".toInt()
    try {
        println(1 / integerZero)
    } catch (e: ArithmeticException) {
        println("1 / 0 : ${e::class.simpleName} - ${e.message}")
    }

    // algunas funciones del paquete kotlin.math
    val y = 4.0
    val x = sqrt(y)
    println("sqrt(4.0) = $x")
    println("2.0.pow(10) = ${2.0.pow(10)}, 2.0.pow(0.5) = ${2.0.pow(0.5)}")
    println("abs(-3.5) = ${abs(-3.5)}, max(3, 7) = ${max(3, 7)}, (-7).absoluteValue = ${(-7).absoluteValue}")
    println("PI = $PI, cos(PI) = ${cos(PI)}")
    println("exp(1.0) = ${exp(1.0)}, ln(E) = ${ln(E)}, log10(1000.0) = ${log10(1000.0)}")
    println("floor(-2.5) = ${floor(-2.5)}, ceil(-2.5) = ${ceil(-2.5)}, truncate(-2.5) = ${truncate(-2.5)}")
    // roundToInt redondea al entero más cercano, las mitades hacia arriba; devuelve un Int
    println("2.5.roundToInt() = ${2.5.roundToInt()}, (-2.5).roundToInt() = ${(-2.5).roundToInt()}")
    // round redondea las mitades al número par más cercano; devuelve un Double
    println("round(2.5) = ${round(2.5)}, round(3.5) = ${round(3.5)}")
    // coerceIn lleva un valor de vuelta a un rango
    println("150.coerceIn(0, 100) = ${150.coerceIn(0, 100)}")
    // los métodos de la clase Math de Java siguen siendo utilizables
    println("Math.sqrt(4.0) = ${Math.sqrt(4.0)}, Math.round(2.5) = ${Math.round(2.5)}")

    // precedencia: * / % antes que + -
    println("2 + 3 * 4 = ${2 + 3 * 4}, (2 + 3) * 4 = ${(2 + 3) * 4}")
    println("10 - 4 - 3 = ${10 - 4 - 3}, \"x\" + 1 + 2 = ${"x" + 1 + 2}")

    // los reales Double son aproximaciones binarias
    println("0.1 + 0.2 = ${0.1 + 0.2}")
    // BigDecimal calcula exactamente en base 10, con los operadores + - * /
    val a = BigDecimal("0.1")
    val b = "0.2".toBigDecimal()
    println("BigDecimal : 0.1 + 0.2 = ${a + b}")
    val price = BigDecimal("19.99")
    val total = price * 3.toBigDecimal()
    println("3 x 19.99 = $total, with VAT = ${total * BigDecimal("1.2")}")
    // redondeo a 2 decimales, mitades hacia arriba (redondeo comercial)
    println("2.565 rounded = ${BigDecimal("2.565").setScale(2, RoundingMode.HALF_UP)}")
    // el operador / conserva el número de decimales del dividendo
    val three = 3.toBigDecimal()
    println("10 / 3 = ${BigDecimal.TEN / three}, 10.00 / 3 = ${BigDecimal("10.00") / three}")
    // el método divide con una precisión
    println("10 / 3 = ${BigDecimal.TEN.divide(three, MathContext.DECIMAL64)}")
}

Resultados:

> gradlew -q run -Pmain=basics11.Basics11Kt
5 / 2 = 2, 5.0 / 2 = 2.5, 5 / 2.0 = 2.5
5 % 2 = 1, -5 % 2 = -1, 5.5 % 2 = 1.5
(-5).rem(2) = -1, (-5).mod(2) = 1
1 / 0.0 = Infinity, 0 / 0.0 = NaN
1 / 0 : ArithmeticException - / by zero
sqrt(4.0) = 2.0
2.0.pow(10) = 1024.0, 2.0.pow(0.5) = 1.4142135623730951
abs(-3.5) = 3.5, max(3, 7) = 7, (-7).absoluteValue = 7
PI = 3.141592653589793, cos(PI) = -1.0
exp(1.0) = 2.718281828459045, ln(E) = 1.0, log10(1000.0) = 3.0
floor(-2.5) = -3.0, ceil(-2.5) = -2.0, truncate(-2.5) = -2.0
2.5.roundToInt() = 3, (-2.5).roundToInt() = -2
round(2.5) = 2.0, round(3.5) = 4.0
150.coerceIn(0, 100) = 100
Math.sqrt(4.0) = 2.0, Math.round(2.5) = 3
2 + 3 * 4 = 14, (2 + 3) * 4 = 20
10 - 4 - 3 = 3, "x" + 1 + 2 = x12
0.1 + 0.2 = 0.30000000000000004
BigDecimal : 0.1 + 0.2 = 0.3
3 x 19.99 = 59.97, with VAT = 71.964
2.565 rounded = 2.57
10 / 3 = 3, 10.00 / 3 = 3.33
10 / 3 = 3.333333333333333

Comentarios:

  • línea 7: se importan todas las declaraciones del paquete [kotlin.math];
  • línea 11: la división de dos enteros es una división entera. Cada operación se escribe en su propia plantilla: a diferencia de la concatenación en Java, no hay que preocuparse por la precedencia de los operadores respecto del operador +, que construye la cadena;
  • línea 13: el resto tiene el mismo signo que el dividendo; el operador % también se aplica a los números reales;
  • línea 14: [rem] es la función del operador %; [mod] devuelve un resto con el mismo signo que el divisor, igual que [Math.floorMod] en Java. Los paréntesis en [(-5)] son necesarios: [-5.mod(2)] se interpretaría como [-(5.mod(2))], porque una llamada a función mediante el operador punto tiene precedencia sobre el operador menos unario;
  • línea 17: dividir un número real entre cero no provoca un error; devuelve infinito ([Infinity]) o el valor especial [NaN] (“Not a Number”) para 0/0. En [1 / zero], el entero 1 se divide entre un número real: la operación es real. Kotlin no realiza conversiones implícitas entre tipos numéricos, pero los operadores aritméticos aceptan operandos de tipos diferentes: la clase [Int] tiene una función [div(other: Double): Double];
  • líneas 19–23: en cambio, dividir un entero entre cero lanza una excepción [ArithmeticException]. El divisor se obtiene convirtiendo la cadena "0" para que el compilador no conozca su valor;
  • líneas 27–28: el ejemplo anterior. [sqrt] espera y devuelve un [Double]: 2.0. Como Kotlin no convierte implícitamente un [Int] en un [Double], [sqrt(4)] sería rechazado; escribimos [sqrt(4.0)];
  • línea 30: la función [pow] se llama sobre el número que se va a elevar a una potencia;
  • línea 31: [absoluteValue] es una propiedad de extensión, que se usa sin paréntesis;
  • línea 34: [floor] redondea hacia abajo, [ceil] redondea hacia arriba y [truncate] redondea hacia cero. Para obtener un entero truncando un número real, se lo convierte mediante [toInt()], como veremos más adelante;
  • línea 36: [roundToInt] redondea al entero más cercano; un valor exactamente intermedio entre dos enteros se redondea hacia arriba: 2.5 se convierte en 3 y -2.5 en -2. El resultado es un [Int]. Así se comporta [Math.round] de Java;
  • línea 38: tenga en cuenta que la función [round] de Kotlin no se comporta igual que [Math.round] de Java: redondea un valor exactamente intermedio al entero par más cercano (redondeo “bancario”): 2.5 se convierte en 2 y 3.5 en 4. El resultado es un [Double]. Este es el comportamiento de [Math.rint] de Java;
  • línea 39: [coerceIn] ajusta 150 al intervalo [0, 100], igual que [Math.clamp] (Java 21). Las funciones [coerceAtLeast] y [coerceAtMost] establecen un solo límite;
  • línea 42: los métodos de la clase Java [Math];
  • línea 45: precedencia de los operadores, que se muestra a continuación;
  • línea 46: "x" + 1 + 2 se evalúa de izquierda a derecha: "x" + 1 da la cadena "x1", a la que se concatena 2. Para efectuar primero la suma, hay que escribir "x" + (1 + 2); con una plantilla, se escribiría ["x${1 + 2\}"];
  • línea 49: 0.1 y 0.2 no tienen representaciones binarias exactas: su suma no es exactamente 0.3;
  • líneas 51–52: dos valores [BigDecimal] creados a partir de cadenas. No escriba [BigDecimal(0.1)]: el parámetro sería el [Double] 0.1, cuyo valor exacto es 0.1000000000000000055511151231257827021181583404541015625. En cambio, la función [0.1.toBigDecimal()], que usa la cadena "0.1", funciona correctamente;
  • línea 53: la suma exacta, escrita con el operador +;
  • líneas 54–56: [3.toBigDecimal()] convierte un entero. Un producto tiene tantas cifras decimales como la suma de las de sus dos factores: 59.97 × 1.2 = 71.964;
  • línea 58: [setScale(2, RoundingMode.HALF_UP)] redondea a dos cifras decimales, con los valores intermedios entre dos dígitos redondeados en dirección opuesta a cero: es el redondeo comercial;
  • línea 61: una trampa. El operador / de Kotlin llama al método [divide(divisor, RoundingMode.HALF_EVEN)]: el cociente conserva el número de cifras decimales del dividendo, redondeado al valor más cercano. Como 10 no tiene cifras decimales, 10/3 es igual a 3; 10.00/3 es igual a 3.33;
  • línea 63: el método Java [divide], con una precisión especificada mediante [MathContext.DECIMAL64] (16 dígitos significativos). Sin especificar la precisión ni el modo de redondeo, el método [divide] lanzaría [ArithmeticException]: [Non-terminating decimal expansion; no exact representable decimal result.], porque 10/3 no tiene una representación decimal finita. En las divisiones de [BigDecimal], por lo tanto, se elige explícitamente la precisión o el número de cifras decimales y el modo de redondeo: [a.divide(b, 2, RoundingMode.HALF_UP)].

3.4.5.3. Operadores en la evaluación de expresiones aritméticas

El orden de precedencia de los operadores al evaluar una expresión aritmética es el siguiente (de mayor a menor):

[function calls, a.f()], [unary -], [*, /, %], [+, -]

Los operadores dentro del mismo bloque [ ] tienen la misma precedencia. Cuando la precedencia es igual, la evaluación procede de izquierda a derecha: 10 - 4 - 3 se evalúa como (10 - 4) - 3 = 3. Se pueden usar paréntesis para especificar un orden de evaluación diferente.

3.4.5.4. Expresiones relacionales

Los operadores son los siguientes: <, <=, , !=, >, >=; Kotlin añade === y ! (véase más adelante). Su precedencia:

  • >, >=, <, <=;
  • , !=, =, !==.

El resultado de una expresión relacional es el valor booleano [false] si la expresión es falsa, y [true] en caso contrario.

    val x = 5
    val end = x > 4

Comparación de dos caracteres

Sean C1 y C2 dos caracteres. Pueden compararse mediante los operadores <, <=, ==, !=, >, >=. Se comparan sus códigos Unicode, que son números. Según el orden Unicode, se cumplen las siguientes relaciones:

space < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. < 'z' < .. < 'é'

El código Unicode de un carácter [c] lo proporciona su propiedad [c.code], que es de tipo [Int]. En Kotlin, un [Char] no es un número: no se puede escribir ['a' + 'b'] ni asignar un carácter a una variable entera, cosa que Java permite.

Comparación de dos cadenas

Se comparan carácter por carácter. La primera desigualdad que se encuentra entre dos caracteres da lugar a una desigualdad del mismo signo entre las cadenas. Consideremos la comparación de las cadenas "Cart" y "Cat":

1
2
3
4
5
"Cart"    "Cat"
---------------------
'C'   =   'C'
'a'   =   'a'
'r'   <   't'

Esta última desigualdad permite concluir que "Cart" < "Cat." Consideremos la comparación de las cadenas "Cat" y "Catkin." Son iguales hasta que se agota la cadena "Cat". En este caso, la cadena agotada se declara la "menor". Por lo tanto, se cumple la relación "Cat" < "Catkin."

Igualdad estructural e igualdad referencial

En este aspecto, Kotlin corrige una trampa clásica de Java. En Java, aplicados a dos cadenas (o a cualesquiera dos objetos), los operadores == y != comparan referencias: [s1 == s2] es verdadero si las dos variables apuntan al mismo objeto en memoria, no si las dos cadenas contienen los mismos caracteres; para comparar el contenido, hay que escribir [s1.equals(s2)]. En Kotlin:

  • el operador == compara el contenido: [a == b] es traducido por el compilador en una llamada al método [a.equals(b)], precedida de una prueba de [null]: si [a] es igual a [null], [a == b] equivale a [b === null], sin riesgo de [NullPointerException]. Esta es la igualdad estructural; != es su negación;
  • el operador === compara referencias: [a === b] es verdadero si [a] y [b] hacen referencia al mismo objeto. Esta es la igualdad referencial; !== es su negación. Rara vez se necesita.

Para los tipos primitivos ([Int], [Double]...), == simplemente compara los valores. C# se comporta igual que Kotlin con las cadenas: su operador == compara su contenido.

El orden de dos cadenas

Los operadores < <= > >= se aplican a las cadenas, igual que a cualquier objeto comparable: en Kotlin, [a < b] es otra forma de escribir [a.compareTo(b) < 0]. El método [compareTo] devuelve un entero:

  • cero si las dos cadenas son iguales;
  • positivo si la cadena n.º 1 es mayor que la cadena n.º 2;
  • negativo si la cadena n.º 1 es menor que la cadena n.º 2.

Las funciones [equals] y [compareTo] de Kotlin aceptan un parámetro [ignoreCase] para ignorar la distinción entre mayúsculas y minúsculas: [s1.equals(s2, ignoreCase = true)] (las funciones de Java [equalsIgnoreCase] y [compareToIgnoreCase]). La sintaxis [ignoreCase = true] es la de un argumento con nombre, que volveremos a encontrar con las funciones.

[compareTo] compara los códigos Unicode carácter por carácter: su resultado es la diferencia entre los códigos de los dos primeros caracteres distintos, o la diferencia de longitudes si una de las cadenas es el comienzo de la otra. Este no es el orden lexicográfico: como el código de 'é' (233) es mayor que el de 'f' (102), "élan" va después de "face." Para ordenar texto destinado a los usuarios, se utiliza un objeto [Collator] (del paquete [java.text] del JDK), que aplica las reglas de ordenación de un idioma determinado. [compareTo] sigue siendo el método correcto para identificadores, palabras clave y nombres de archivo.

El programa [Basics12.kt] es el siguiente:

// expresiones relacionales y comparación de cadenas
package basics12

import java.math.BigDecimal
import java.text.Collator
import java.util.Locale

fun main() {
    val x = 5
    val end = x > 4
    println("x > 4 : $end, x == 5 : ${x == 5}, x != 5 : ${x != 5}")

    // comparación de caracteres: se comparan sus códigos Unicode
    println("'a' < 'b' : ${'a' < 'b'}, 'Z' < 'a' : ${'Z' < 'a'}, '9' < 'A' : ${'9' < 'A'}")
    println("codes : 'A'=${'A'.code}, 'a'=${'a'.code}, 'é'=${'é'.code}")

    // comparación de cadenas: == compara el contenido, compareTo y < > el orden
    val string1 = "cat"
    val string2 = "dog"
    val n = string1.compareTo(string2)
    val equal = string1 == string2
    println("n=$n, equal=$equal, string1 < string2 : ${string1 < string2}")
    println("\"Cat\".compareTo(\"Catkin\") : ${"Cat".compareTo("Catkin")}")

    // == compara el contenido, === las referencias
    val string3 = "CAT".lowercase()
    println("string3=$string3, string1 == string3 : ${string1 == string3}")
    println("string1 === string3 : ${string1 === string3}, string1 === \"cat\" : ${string1 === "cat"}")
    // == acepta el valor null
    val absent: String? = System.getProperty("unknown.property")
    println("absent == string1 : ${absent == string1}, absent == null : ${absent == null}")

    // compareTo compara los códigos Unicode, carácter por carácter
    println("\"élan\".compareTo(\"face\") : ${"élan".compareTo("face")}")
    println("\"Cat\".compareTo(\"cat\") : ${"Cat".compareTo("cat")}")
    // sin distinguir mayúsculas de minúsculas
    println("compareTo with ignoreCase = true : ${"Cat".compareTo("cat", ignoreCase = true)}")
    println("\"Cat\" == \"cat\" : ${"Cat" == "cat"}")
    println("\"Cat\".equals(\"cat\", ignoreCase = true) : ${"Cat".equals("cat", ignoreCase = true)}")
    // un Collator compara según las reglas de ordenación de un idioma
    val collator = Collator.getInstance(Locale.FRENCH)
    println("collator.compare(\"élan\", \"face\") : ${collator.compare("élan", "face")}")
    println("collator.compare(\"Cat\", \"cat\") : ${collator.compare("Cat", "cat")}")

    // == llama a equals: para un BigDecimal, 2.0 y 2.00 son diferentes
    val m1 = BigDecimal("2.0")
    val m2 = BigDecimal("2.00")
    println("m1 == m2 : ${m1 == m2}, m1.compareTo(m2) : ${m1.compareTo(m2)}, m1 >= m2 : ${m1 >= m2}")
}

Resultados:

> gradlew -q run -Pmain=basics12.Basics12Kt
x > 4 : true, x == 5 : true, x != 5 : false
'a' < 'b' : true, 'Z' < 'a' : true, '9' < 'A' : true
codes : 'A'=65, 'a'=97, 'é'=233
n=-1, equal=false, string1 < string2 : true
"Cat".compareTo("Catkin") : -3
string3=cat, string1 == string3 : true
string1 === string3 : false, string1 === "cat" : true
absent == string1 : false, absent == null : true
"élan".compareTo("face") : 131
"Cat".compareTo("cat") : -32
compareTo with ignoreCase = true : 0
"Cat" == "cat" : false
"Cat".equals("cat", ignoreCase = true) : true
collator.compare("élan", "face") : -1
collator.compare("Cat", "cat") : 1
m1 == m2 : false, m1.compareTo(m2) : 0, m1 >= m2 : true

Comentarios:

  • Línea 10: una expresión relacional; [end] es de tipo [Boolean];
  • línea 14: comparación de caracteres;
  • línea 15: la propiedad [code] de un carácter devuelve su código Unicode (en Java, esto se escribe [(int) 'A']);
  • línea 20: a la variable [n] se le asigna un entero negativo porque "cat" < "dog": la diferencia entre los códigos de 'c' (99) y 'd' (100);
  • línea 21: la variable [equal] tiene el valor [true] si las dos cadenas tienen el mismo contenido, y [false] en caso contrario;
  • línea 22: el operador < aplicado a dos cadenas;
  • línea 23: la cadena que se agota primero es la más corta; el resultado es la diferencia de longitudes: 3 - 6. En un literal de cadena, \" representa unas comillas;
  • línea 26: la función [lowercase()] construye, en tiempo de ejecución, un nuevo objeto de cadena que contiene "cat";
  • líneas 27–28: [string1] and [string3] tienen el mismo contenido, pero hacen referencia a dos objetos distintos: == devuelve [true], === devuelve [false]. Sin embargo, [string1 === "cat"] es verdadero: dos literales de cadena idénticos se almacenan una sola vez en memoria;
  • línea 30: el método Java [System.getProperty] devuelve el valor de una propiedad de la JVM, o [null] si no existe; su resultado se almacena en una variable de tipo [String?];
  • línea 31: el operador == acepta un valor [null] a la izquierda: devuelve [false], mientras que la llamada Java a [absent.equals(string1)] lanzaría [NullPointerException];
  • línea 34: 233 - 102 = 131: para [compareTo], "élan" va después de "face";
  • línea 35: 'C' (67) - 'c' (99) = -32;
  • líneas 37–39: sin distinguir mayúsculas de minúsculas, “Cat” y “cat” son iguales;
  • líneas 41–43: un [Collator] para francés: “élan” precede a “face,” y “Cat” sigue a “cat” (cuando las letras son las mismas, la minúscula va antes que la mayúscula). El método [compare] devuelve un entero negativo, cero o positivo, igual que [compareTo];
  • líneas 46–48: como == llama a [equals], hereda las características de ese método. El comportamiento de la clase [BigDecimal] tiene en cuenta el número de cifras decimales: 2.0 y 2.00 son diferentes para [equals], pero iguales para [compareTo], y por lo tanto para los operadores <<, <=, >> y >=. Para comparar dos montos [BigDecimal], por lo tanto, se debe usar [compareTo(...) == 0], no ==.

3.4.5.5. Expresiones booleanas

Los operadores que pueden utilizarse son AND (&&), OR (||) y NOT (!). El resultado de una expresión booleana es un valor booleano. Precedencia de los operadores:

  • ! ;
  • && ;
  • ||.
    val x = 3.5
    val valid = x > 2 && x < 4

Los operadores relacionales tienen mayor precedencia que los operadores && y ||. Estos dos operadores evalúan su operando derecho solo si es necesario: en [a && b], b no se evalúa si a es falso; en [a || b], b no se evalúa si a es verdadero. Esto se denomina “evaluación en cortocircuito”. Por lo tanto, se puede escribir sin riesgo [text != null && text.length > 0]: en el lado derecho, el compilador sabe que [text] no es igual a [null] (conversión inteligente de tipos). Las funciones [and] y [or], cuando se aplican a dos booleanos ([a and b], [a or b]), realizan el mismo cálculo pero siempre evalúan ambos operandos; la función [xor] es el OR exclusivo. La prueba para determinar si un valor está dentro de un intervalo se escribe de forma más sencilla con el operador [in]: [x in 2.0..4.0] es verdadero si 2 ≤ x ≤ 4.

3.4.5.6. Operaciones bit a bit

Kotlin no tiene operadores simbólicos para las operaciones bit a bit: los << >> >>> & | ^ ~ de Java se reemplazan por funciones infijas; es decir, funciones de un solo argumento que se escriben entre sus dos operandos, sin punto ni paréntesis: [i shl 4] es otra forma de escribir [i.shl(4)]. Sean [i] y [j] dos enteros ([Int] o [Long]):

Operación
En Java
Descripción
i shl n
i << n
desplaza i n bits a la izquierda. Los bits que entran son ceros
i shr n
i >> n
desplaza i n bits a la derecha. Se conserva el bit de signo
i ushr n
i >>> n
Desplazamiento a la derecha sin signo: los bits que entran son ceros, incluso si i es negativo
i and j
i & j
realiza el AND lógico bit a bit de i y j
i or j
i|j
realiza el OR lógico bit a bit de i y j
i xor j
i ^ j
realiza la operación de OR exclusivo bit a bit entre i y j
i.inv()
~i
complementa i a 1

Los desplazamientos están definidos solo para los tipos [Int] y [Long] (y para los tipos sin signo [UInt] y [ULong], para los cuales el desplazamiento [shr] siempre rellena con ceros): para un [Short] o un [Byte], el valor se convierte primero a [Int]. Por lo tanto, el compilador rechaza [s shl 1] si [s] es un [Short]: [unresolved reference 'shl' on receiver of type 'Short']. Estas operaciones se usan principalmente para manipular datos binarios; los nombres explícitos tienen la ventaja de no confundirse con los operadores booleanos && y ||.

El programa [Basics13.kt] es el siguiente:

// manipulación de bits
package basics13

fun main() {
    val i = 100
    val j = -13
    // %08x: el entero en hexadecimal, en 8 dígitos (32 bits)
    println("i=0x%08x, j=0x%08x".format(i, j))
    println("i shl 4=0x%08x, i shr 4=0x%08x".format(i shl 4, i shr 4))
    println("i and j=0x%08x, i or j=0x%08x".format(i and j, i or j))
    println("i xor j=0x%08x, i.inv()=0x%08x".format(i xor j, i.inv()))
    println("j shl 2=0x%08x, j shr 2=0x%08x".format(j shl 2, j shr 2))
    // los mismos valores en binario (16 bits de menor peso)
    println("i=${binary(i, 16)}, j=${binary(j, 16)}, i and j=${binary(i and j, 16)}")
    // desplazamiento a la derecha sin signo ushr: los bits entrantes son ceros
    val m = -16
    println("m=${binary(m, 32)}")
    println("m shr 2=${binary(m shr 2, 32)}")
    println("m ushr 2=${binary(m ushr 2, 32)}")
    // un entero sin signo: shr introduce ceros
    val k = 0xF123_0000U
    println("k=${k.toString(16)}, k shr 4=${(k shr 4).toString(16)}, k=$k")
}

// los n bits de menor peso de value, como una cadena de 0 y 1
fun binary(value: Int, n: Int): String = buildString {
    for (rank in n - 1 downTo 0) {
        append((value ushr rank) and 1)
    }
}

Resultados:

> gradlew -q run -Pmain=basics13.Basics13Kt
i=0x00000064, j=0xfffffff3
i shl 4=0x00000640, i shr 4=0x00000006
i and j=0x00000060, i or j=0xfffffff7
i xor j=0xffffff97, i.inv()=0xffffff9b
j shl 2=0xffffffcc, j shr 2=0xfffffffc
i=0000000001100100, j=1111111111110011, i and j=0000000001100000
m=11111111111111111111111111110000
m shr 2=11111111111111111111111111111100
m ushr 2=00111111111111111111111111111100
k=f1230000, k shr 4=f123000, k=4045602816

Comentarios:

  • líneas 5–6: dos enteros de tipo [Int] (32 bits);
  • línea 8: el especificador %08x muestra un entero en hexadecimal (x) de 8 dígitos, rellenado con ceros (08), que representa sus 32 bits: -13 se convierte en fffffff3;
  • línea 9: desplazar 100 (0x64) 4 bits a la izquierda equivale a multiplicarlo por 2⁴ (0x640); desplazarlo a la derecha equivale a dividirlo entre 2⁴ (0x6);
  • líneas 10–11: AND, OR, XOR (OR exclusivo bit a bit) y el complemento a uno. Observe que la función [inv] se llama como un método normal, con punto y paréntesis;
  • línea 12: desplazamientos de un número negativo. [shr] conserva el bit de signo: -13 desplazado 2 bits a la derecha da -4 (0xfffffffc);
  • línea 14: la función [binary] (líneas 26–28) muestra los n bits menos significativos de un entero. Se verifica bit a bit el AND lógico de i y j;
  • líneas 16–19: el desplazamiento [shr] conserva el bit de signo de m, que es negativo; el desplazamiento [ushr] rellena con ceros;
  • líneas 21–22: un entero sin signo [UInt], cuyo bit más significativo es 1: es igual a 4,045,602,816, mientras que un [Int] con los mismos bits sería negativo. Su desplazamiento [shr] inserta ceros. La función [toString(16)] lo escribe en hexadecimal;
  • línea 26: la función [buildString] construye una cadena mediante adiciones sucesivas: en el bloque siguiente, la función [append] agrega un elemento a la cadena que se está construyendo. Se presentará en el capítulo 5. El bucle [for (rank in n - 1 downTo 0)] recorre [rank] desde n-1 hasta 0 en orden descendente; los bucles se describen más adelante;
  • línea 28: [(value ushr rank) and 1] pone a 0 el bit n.º [rank] y luego lo separa de los demás.

3.4.5.7. Combinación de operadores

[a = a + b] puede escribirse [a += b]; [a = a - b] puede escribirse [a -= b]. Lo mismo se aplica a los operadores *, / y %. Así, [a = a / 2] puede escribirse [a /= 2]. Como las operaciones bit a bit son funciones, no tienen operador combinado: se escribe [a = a shl 2]. Al igual que las asignaciones simples, las asignaciones compuestas son instrucciones, no expresiones. No realizan ninguna conversión implícita: si [s] es un [Short], [s += 1] se rechaza, al igual que [s = s + 1], porque el resultado de la suma es un [Int]; se escribe [s = (s + 1).toShort()]. [Short] y [Byte] se usan, de hecho, rara vez en los cálculos.

3.4.5.8. Operadores de incremento y decremento

La notación [variable++] significa [variable = variable + 1] o [variable += 1]. La notación [variable--] significa [variable = variable - 1] o [variable -= 1]. Se aplican a una variable [var]. Cuando se utilizan en una expresión, estos operadores tienen dos formas:

  • [i++] (posfija): el valor de la expresión es el valor de i antes de el incremento;
  • [++i] (prefija): el valor de la expresión es el valor de i después de el incremento.

Kotlin los ha conservado, aunque la asignación no sea una expresión; sin embargo, conviene evitar usarlos dentro de expresiones más grandes, donde perjudican la legibilidad.

3.4.5.9. Sin operador ternario: la expresión if

Java, al igual que C y C#, tiene un operador ternario: la expresión [cond ? expr1 : expr2] se evalúa como [expr1] si la condición [cond] es verdadera, y como [expr2] en caso contrario. Kotlin no tiene operador ternario; el compilador rechaza [val z = x > 4 ? x + 1 : x - 1] con el mensaje [syntax error: Unexpected tokens (use ';' to separate expressions on the same line)]. No lo necesita, porque su instrucción *[if] es también una expresión* que tiene un valor:

val i = if (j > 4) j + 1 else j - 1

La expresión [if (cond) expr1 else expr2] se evalúa de la siguiente manera:

  • Se evalúa la expresión [cond] . Es una expresión booleana;
  • si es verdadera, el valor de la expresión es el de [expr1], y [expr2] no se evalúa;
  • si es falsa, ocurre lo contrario: el valor de la expresión es el de [expr2], y [expr1] no se evalúa.

La operación anterior asignará el valor j+1 a la variable [i] si j > 4, y j-1 en caso contrario. Es lo mismo que escribir [if (j > 4) i = j + 1 else i = j - 1], pero es más conciso, y [i] puede declararse con [val]. Cuando se usa como expresión, [if] debe tener una rama [else] para que la expresión se evalúe como un valor en todos los casos. Encontraremos [if] en la sección “Estructura de selección simple”, y [when], que también es una expresión, en la sección “Estructura de casos”.

3.4.5.10. Operadores de nulabilidad

A diferencia de Java, Kotlin tiene operadores dedicados al valor [null]. Los vimos en la sección “Seguridad frente a nulos”; aquí se presenta un resumen. Sea [a] una expresión que admite valores nulos:

Operador
Función
[a?.member]
Llamada segura: se evalúa como [a.member] si a no es [null], y como [null] en caso contrario (el miembro no se evalúa entonces: no se llama a la función). Las llamadas seguras se encadenan: [a?.b?.c] se evalúa como [null] en cuanto cualquiera de los eslabones se evalúa como [null]
[a ?: b]
Operador Elvis: se evalúa como a si a no es igual a [null], y como b en caso contrario (b se evalúa entonces solo si a es igual a [null]). Se utiliza para proporcionar un valor de respaldo
[a!!]
aserción: se evalúa como a si a no es igual a [null]; lanza una [NullPointerException] en caso contrario
[a?.let { ... \}]
ejecuta el bloque, donde el valor de a se denomina [it], solo si a no es igual a [null]

Son los equivalentes de los operadores ?. y ?? de C#. Java, que no los tiene, recurre en su lugar al operador ternario ([a != null ? a : b]), al método [Objects.requireNonNullElse(a, b)], o a la clase [Optional] y su método [map] . El lado derecho del operador Elvis también puede ser una instrucción que interrumpe la ejecución normal: [val n = input ?: return] sale de la función si [input] se evalúa como [null], y [val n = input ?: throw IllegalArgumentException("missing input")] lanza una excepción; volveremos sobre esta forma al hablar de las excepciones.

El programa [Basics14.kt] combina estos diferentes operadores:

// otros operadores
package basics14

// devuelve el valor asociado a una clave, o null si la clave es desconocida
fun valueOf(key: String): String? = if (key == "title") "Kotlin by example" else null

fun main() {
    // expresiones booleanas
    val x = 3.5
    val valid = x > 2 && x < 4
    println("valid=$valid, !valid=${!valid}, valid || x > 10 : ${valid || x > 10}")
    println("x in 2.0..4.0 : ${x in 2.0..4.0}, valid xor true : ${valid xor true}")

    // operadores compuestos
    var a = 10
    a += 5
    print("a += 5 : $a")
    a *= 2
    print(", a *= 2 : $a")
    a /= 4
    print(", a /= 4 : $a")
    a %= 4
    print(", a %= 4 : $a")
    // no hay operador compuesto para las operaciones de bits
    a = a shl 2
    println(", a = a shl 2 : $a")

    // incremento y decremento
    var i = 5
    val j = i++    // j recibe el valor anterior de i, luego i se incrementa
    val k = ++i    // i se incrementa, luego k recibe el nuevo valor de i
    println("i=$i, j=$j, k=$k")
    i--
    println("i=$i")

    // no hay operador ternario: if es una expresión
    val n = 5
    val p = if (n > 4) n + 1 else n - 1
    val parity = if (n % 2 == 0) "even" else "odd"
    println("p=$p, $n is $parity")

    // valor de reemplazo si una referencia es null: el operador Elvis ?:
    val input = valueOf("name")
    val name = input ?: "unknown"
    val age: Int? = "twenty".toIntOrNull()
    val displayedAge = age ?: -1
    println("name=$name, displayedAge=$displayedAge")
    // asignación solo si la variable es null
    var title = valueOf("subtitle")
    if (title == null) {
        title = "Untitled"
    }
    println("title=$title")
    // acceso a un miembro solo si el objeto no es nulo: la llamada segura ?.
    var text = valueOf("text")
    println("length=${text?.length}")
    text = valueOf("title")
    println("length=${text?.length ?: -1}")
    // llamadas seguras encadenadas
    println("first word: ${valueOf("title")?.split(" ")?.first()?.uppercase()}")
    println("first word: ${valueOf("author")?.split(" ")?.first()?.uppercase() ?: "none"}")
    // la aserción !!: NullPointerException si el valor es null
    println("title!!.length=${valueOf("title")!!.length}")
}

Resultados:

> gradlew -q run -Pmain=basics14.Basics14Kt
valid=true, !valid=false, valid || x > 10 : true
x in 2.0..4.0 : true, valid xor true : false
a += 5 : 15, a *= 2 : 30, a /= 4 : 7, a %= 4 : 3, a = a shl 2 : 12
i=7, j=5, k=7
i=6
p=6, 5 is odd
name=unknown, displayedAge=-1
title=Untitled
length=null
length=17
first word: KOTLIN
first word: none
title!!.length=17

Comentarios:

  • línea 5: una función que devuelve una cadena para la clave "title", y [null] para cualquier otra clave. Proporciona al programa valores de tipo [String?];
  • línea 10: una expresión booleana;
  • línea 12: la misma prueba de rango, escrita con el operador [in]; [valid xor true] es el OR exclusivo de dos booleanos;
  • líneas 15–26: operadores combinados: 10 + 5 = 15, 15 × 2 = 30, 30 ÷ 4 = 7 (división entera), 7 % 4 = 3, 3 shl 2 = 12. La variable [a] se declara con [var], ya que su valor cambia;
  • línea 30: a [j] se le asigna 5 y luego [i] se establece en 6;
  • línea 31: [i] pasa a 7 y luego a [k] se le asigna 7;
  • líneas 38–39: dos expresiones [if], que reemplazan los operadores ternarios de Java;
  • líneas 43–44: [input] es igual a [null]: a [name] se le asigna “unknown.” Su tipo es [String], no [String?]: el operador Elvis garantiza que [name] nunca sea [null];
  • línea 46: [age], de tipo [Int?], es igual a [null]: a [displayedAge], de tipo [Int], se le asigna -1. No hay desempaquetado ni riesgo de excepción;
  • líneas 49–51: la asignación se realiza solo si [title] es igual a [null]. Podríamos haberlo escrito de forma más sencilla como [val title = valueOf("subtitle") ?: "Untitled"];
  • línea 56: [text] es igual a [null]; [text?.length] es igual a [null], sin que se haya leído la propiedad [length] ; una plantilla muestra [null];
  • línea 58: [text] es "Kotlin by example": su longitud es 17. El operador Elvis devolvería -1 para un valor [null];
  • línea 60: una cadena de llamadas seguras. [split(" ")] divide la cadena en una lista de palabras (capítulo 5), [first()] devuelve la primera palabra y [uppercase()] la convierte a mayúsculas;
  • línea 61: la misma secuencia de llamadas aplicada a un valor [null]: no se realiza ninguna llamada, la expresión se evalúa como [null], y el operador Elvis la reemplaza por "none";
  • línea 63: la aserción !!. [valueOf("title")] es de tipo [String?], pero el programador sabe que no es igual a [null] para la clave “title”; la aserción permite usar [length] directamente. Para la clave "author", habría lanzado una [NullPointerException].

3.4.5.11. Precedencia general de los operadores

La siguiente tabla enumera la precedencia de los operadores en Kotlin, de mayor a menor:

Operadores
Asociatividad
[x.y] [x?.y] [f(x)] [a[i]] [x++] [x--] [x!!] (posfijos)
LR
[+x] [-x] [!x] [++x] [--x] (prefijos)
RL
[as] [as?] (cambio de tipo)
LR
[*] [/] [%]
LR
[+] [-]
LR
[..] [..<] (intervalos)
LR
funciones infijas: [shl] [shr] [ushr] [and] [or] [xor] [downTo] [step] [until]...
LR
[?:] (Elvis)
LR
[in] [!in] [is] [!is]
LR
[<] [<=] [>] [>=]
LR
[==] [!=] [===] [!==]
LR
[&&]
LR
[||]
LR
[=] [+=] [-=] [*=] [/=] [%=] (instrucciones)
 

"LR" indica que, cuando los operadores tienen igual precedencia, se sigue el orden de izquierda a derecha: cuando una expresión contiene operadores de la misma precedencia, se evalúa primero el operador situado más a la izquierda. "RL" indica el orden de derecha a izquierda. Hay tres puntos importantes que conviene señalar:

  • las funciones infijas tienen menor precedencia que los operadores aritméticos: [1 shl 2 + 3] es igual a [1 shl 5], es decir, 32;
  • tienen mayor precedencia que las comparaciones: [x and 1 == 0] se evalúa como [(x and 1) == 0], que es justamente lo que se pretende (en Java, [x & 1 == 0] se rechaza porque == tiene mayor precedencia que &);
  • el operador Elvis tiene menor precedencia que los operadores aritméticos: [a ?: 0 + 1] se evalúa como [a ?: (0 + 1)]. Para sumar 1 al resultado, hay que escribir [(a ?: 0) + 1], como hizo el programa [Basics06.kt].

Ante la duda, no dude en usar paréntesis: también facilitan la lectura de la expresión.

3.4.5.12. Conversiones de tipo

En una expresión, es posible cambiar temporalmente la codificación de un valor. Esto se denomina cambio de tipo de datos, o “conversión de tipo” (“type casting”). Java lo hace de dos maneras:

  • las conversiones de ampliación (por ejemplo, de un [int] a un [long] o a un [double]) las realiza automáticamente el compilador;
  • las conversiones de restricción, que pueden provocar una pérdida de información, como de un [double] a un [int], las especifica el programador mediante la notación [(type) value].

Kotlin es más estricto: no realiza ninguna conversión implícita entre tipos numéricos, ni siquiera las de ampliación. Toda conversión debe solicitarse explícitamente mediante una de las funciones [toByte()], [toShort()], [toInt()], [toLong()], [toFloat()] o [toDouble()], que posee cada tipo numérico (y [toUInt()], [toULong()]... para los tipos sin signo). Por lo tanto, el compilador rechaza:

1
2
3
4
5
val i = 3
val l: Long = i
error: initializer type mismatch: expected 'Long', actual 'Int'.
val f: Float = i / 4
error: initializer type mismatch: expected 'Float', actual 'Int'.

Hay que escribir [val l: Long = i.toLong()]. Este rigor evita que se produzcan conversiones sin que el programador lo sepa, en particular las que pierden precisión sin previo aviso (como un [long] convertido a [float] o [double] en Java). Tiene dos modalidades:

  • un literal se acepta para cualquier tipo en el que quepa: [val l: Long = 1000] y [val b: Byte = 5] son aceptados;
  • los operadores aritméticos y las comparaciones aceptan operandos de diferentes tipos numéricos: [i + l], donde [i] es un [Int], [l] es un [Long], el resultado es un [Long]; [i * 1.5] es un [Double]. Esto no es una conversión implícita, sino la existencia, dentro de la clase [Int], de funciones [plus(other: Long): Long], [times(other: Double): Double], etc.

Las conversiones que pueden perder información tienen, con las funciones [toXxx()], el mismo efecto que las conversiones de tipo (casts) de Java: [toInt()] aplicada a un número de punto flotante trunca la parte decimal (hacia cero); aplicada a un [Long], conserva solo los 32 bits menos significativos. La conversión de tipo de Kotlin, el operador [as], está reservada para los objetos (capítulo 4): [d as Int], donde [d] es un [Double], no convierte un número de punto flotante en un entero: el compilador emite una advertencia ([this cast can never succeed. Use 'toInt' to perform numeric conversion.]), y en tiempo de ejecución se lanzaría una excepción ([ClassCastException]).

Los caracteres no son números: se convierte un carácter en su código Unicode mediante la propiedad [code], y un código en un carácter mediante el constructor [Char(code)]. Sin embargo, se puede sumar un entero a un carácter (['A' + 2] es igual a 'C') y restar dos caracteres (['C' - 'A'] es igual a 2).

Un desbordamiento en un cálculo con enteros o en una conversión entre enteros nunca se notifica: el resultado simplemente es incorrecto. El compilador de Kotlin tampoco lo notifica, incluso cuando solo intervienen constantes ([Int.MAX_VALUE + 1]). Cuando existe este riesgo, se debe realizar el cálculo con un tipo más grande ([Long], o [BigInteger] del JDK) o utilizar los métodos [addExact], [subtractExact], [multiplyExact], [toIntExact]... de la clase Java [Math], que lanzan una excepción [ArithmeticException] si se supera el límite. La biblioteca de Kotlin no tiene ningún equivalente.

El programa [Basics15.kt] es el siguiente:

// cambios de tipo
package basics15

import kotlin.math.roundToInt

fun main() {
    val i = 3
    val j = 4
    val f1 = (i / j).toFloat()
    val f2 = i.toFloat() / j
    println("f1=$f1, f2=$f2")

    // no hay conversión implícita, ni siquiera sin pérdida de información
    val l: Long = i.toLong()
    val d: Double = l.toDouble()
    println("l=$l, d=$d")
    // pero los operadores aceptan operandos de tipos diferentes
    val sum = i + l
    val product = i * 1.5
    println("i + l = $sum (${sum::class.simpleName}), i * 1.5 = $product (${product::class.simpleName})")

    // conversiones con posible pérdida de información
    val real = 3.99
    val truncated = real.toInt()
    val rounded = real.roundToInt()
    println("3.99.toInt()=$truncated, (-3.99).toInt()=${(-3.99).toInt()}, 3.99.roundToInt()=$rounded")
    val big = 3_000_000_000L
    val overflowed = big.toInt()
    println("3000000000L.toInt()=$overflowed")
    // un real demasiado grande se lleva al mayor valor entero
    println("1e10.toInt()=${1e10.toInt()}, Double.NaN.toInt()=${Double.NaN.toInt()}")

    // caracteres y enteros
    val c = Char(65)
    val code = 'é'.code
    println("Char(65)=$c, code of 'é'=$code, 'A' + 2=${'A' + 2}, 'C' - 'A'=${'C' - 'A'}")
    // un dígito y su valor
    println("'7'.digitToInt()=${'7'.digitToInt()}, '7'.code=${'7'.code}")

    // desbordamiento: silencioso
    val max = Int.MAX_VALUE
    val next = max + 1
    println("Int.MAX_VALUE + 1 = $next, as a Long: ${max.toLong() + 1}")
    // los métodos ...Exact de la clase Math de Java señalan el desbordamiento con una excepción
    try {
        val checked = Math.addExact(max, 1)
        println("checked=$checked")
    } catch (e: ArithmeticException) {
        println("Math.addExact(max, 1) : ${e::class.simpleName} - ${e.message}")
    }
    try {
        val conversion = Math.toIntExact(big)
        println("conversion=$conversion")
    } catch (e: ArithmeticException) {
        println("Math.toIntExact(big) : ${e::class.simpleName} - ${e.message}")
    }
}

Resultados:

> gradlew -q run -Pmain=basics15.Basics15Kt
f1=0.0, f2=0.75
l=3, d=3.0
i + l = 6 (Long), i * 1.5 = 4.5 (Double)
3.99.toInt()=3, (-3.99).toInt()=-3, 3.99.roundToInt()=4
3000000000L.toInt()=-1294967296
1e10.toInt()=2147483647, Double.NaN.toInt()=0
Char(65)=A, code of 'é'=233, 'A' + 2=C, 'C' - 'A'=2
'7'.digitToInt()=7, '7'.code=55
Int.MAX_VALUE + 1 = -2147483648, as a Long: 2147483648
Math.addExact(max, 1) : ArithmeticException - integer overflow
Math.toIntExact(big) : ArithmeticException - integer overflow

Comentarios:

  • línea 9: [f1] tendrá el valor 0.0. La división 3/4 es una división entera, ya que ambos operandos son de tipo [Int]; su resultado, 0, se convierte luego a [Float] mediante la función [toFloat()];
  • línea 10: [i.toFloat()] es el valor de [i] convertido a [Float]. Ahora tenemos una división entre un número real de tipo [Float] y un entero de tipo [Int], cuyo resultado es [Float]: se efectúa la división de los dos números reales, y [f2] tiene el valor 0.75. En la operación [i.toFloat()], [i] es un valor codificado exactamente como un número real de 4 bytes, mientras que [i.toFloat()] es el mismo valor codificado como un número real aproximado de 4 bytes. Esta transcodificación solo ocurre durante el cálculo: la variable [i] conserva siempre su tipo [Int];
  • líneas 14–15: conversiones ascendentes (upcasts), que deben solicitarse explícitamente;
  • líneas 18–19: operaciones entre tipos diferentes. El tipo del resultado se muestra mediante [::class.simpleName]: [Long] y [Double];
  • línea 24: convertir un número real en entero trunca la parte decimal hacia cero: 3.99 se convierte en 3 y -3.99 en -3;
  • línea 25: para redondear, usamos [roundToInt()] del paquete [kotlin.math], importado en la línea 4, que devuelve directamente un [Int];
  • línea 27: 3 mil millones excede el rango de [Int]: el literal es de tipo [Long], con o sin el sufijo L;
  • línea 28: 3 mil millones no caben en un [Int]: solo se conservan los 32 bits menos significativos, y el resultado carece de sentido;
  • línea 31: un número de punto flotante demasiado grande para un [Int] se reduce a [Int.MAX_VALUE]; el valor [NaN] se convierte en 0;
  • líneas 34–36: conversiones entre caracteres y códigos Unicode, y aritmética de caracteres;
  • línea 38: la función [digitToInt()] devuelve el valor de un dígito (7), que no debe confundirse con su código Unicode (55);
  • línea 42: el desbordamiento pasa inadvertido: el resultado es el valor más pequeño de [Int]. El mismo cálculo realizado con [Long] da el resultado correcto;
  • línea 46: con [Math.addExact], el desbordamiento provoca una excepción [ArithmeticException];
  • línea 52: [Math.toIntExact] convierte un [Long] en un [Int] y también lanza una excepción si el valor no cabe en un [Int].

3.5. Instrucciones de control del flujo del programa

3.5.1. Detención

La función [exitProcess] del paquete [kotlin.system] permite detener la ejecución de un programa:

fun exitProcess(status: Int): Nothing

[exitProcess] termina el proceso actual y devuelve el control al proceso que lo llamó, normalmente el intérprete de comandos. El valor de [status], conocido como código de retorno, puede ser utilizado por el intérprete de comandos. Por convención, 0 indica que el programa se ejecutó correctamente, mientras que cualquier otro valor señala un error. En Windows, el código de retorno está disponible en la variable [%ERRORLEVEL%] en el símbolo del sistema y en la variable [$LASTEXITCODE] de PowerShell; en Linux y macOS, en la variable [$?] del shell. Así, [exitProcess(0)] terminará la ejecución del programa con un código de retorno 0.

[exitProcess] llama al método Java [System.exit], que también puede utilizarse directamente. Sin embargo, tiene una ventaja sobre ese método: su tipo de retorno es [Nothing]. [Nothing] es el tipo de las expresiones que nunca devuelven un valor porque no terminan normalmente (finalización del programa, excepción lanzada, bucle infinito). Por lo tanto, el compilador sabe que la instrucción que sigue a una llamada a [exitProcess] nunca se ejecutará, y lo tiene en cuenta en sus verificaciones, como veremos.

Sin una llamada a [exitProcess], un programa termina con un código de retorno 0 cuando finaliza su función [main], posiblemente con una instrucción [return]. Si lo termina una excepción que nadie ha capturado, muestra esa excepción y termina con un código de retorno 1. Como en Java, la función [main] no puede devolver un entero: [exitProcess] es la única manera de especificar el código de retorno.

El programa [Basics16.kt] recibe su código de retorno como argumento:

// detención del programa con un código de salida
package basics16

import kotlin.system.exitProcess

fun main(args: Array<String>) {
    println("Start of the program")
    // el código de salida se pasa como argumento (véase la sección sobre los argumentos del programa)
    // sin argumento o con un argumento no numérico, se obtiene null
    val code = args.firstOrNull()?.toIntOrNull()
    if (code == null) {
        System.err.println("Syntax: java -jar basics16.jar exit_code")
        exitProcess(1)
    }
    // aquí, el compilador sabe que [code] no es nulo: exitProcess nunca regresa
    println("Stopping with exit code $code")
    exitProcess(code)
    println("This line is never executed")
}

Para ver el código de retorno, el programa debe ser el proceso lanzado por el shell. Con [gradlew -q run -Pmain=basics16.Basics16Kt --args="3"], el proceso lanzado es Gradle: un código de retorno distinto de cero hace que la tarea [run] falle, Gradle muestra su propio mensaje de error y lo que recibimos es el código de retorno de Gradle. Por lo tanto, construimos un archivo ejecutable con el compilador [kotlinc], como en el capítulo 2 ([kotlinc Basics16.kt -include-runtime -d basics16.jar]), y lo ejecutamos con [java -jar].

Resultados en un terminal bash:

> java -jar basics16.jar 3
Start of the program
Stopping with exit code 3
> echo $?
3
> java -jar basics16.jar
Start of the program
Syntax: java -jar basics16.jar exit_code
> echo $?
1
> java -jar basics16.jar three
Start of the program
Syntax: java -jar basics16.jar exit_code
> echo $?
1

Comentarios:

  • línea 6: la función [main] recibe los argumentos de la línea de comandos en el arreglo [args]. A continuación se enumeran los argumentos del programa;
  • línea 10: [args.firstOrNull()] devuelve el primer argumento, o [null] si no hay ninguno; el operador [?.] llama a [toIntOrNull()] solo si no es [null], y [toIntOrNull()] devuelve [null] si la cadena no es un entero. Así, tanto la ausencia de argumento como un argumento no numérico dan como resultado [null], que es de tipo [Int?], sin que se lance ninguna excepción. El programa Java correspondiente debía capturar la excepción [NumberFormatException] de [Integer.parseInt];
  • línea 13: el programa termina con un código de retorno 1. El mensaje de error se escribe en la salida de error [System.err];
  • línea 16: el compilador sabe que solo llegamos a este punto si [code] no es [null], ya que el bloque [if] termina con una llamada a una función de tipo [Nothing]. Por lo tanto, la variable [code], declarada como de tipo [Int?], se trata como un [Int] a partir de esta línea: esto se conoce como “smart cast” (conversión inteligente). Sin ella, la llamada a [exitProcess(code)] en la línea siguiente, que espera un [Int], sería rechazada. En Java, el compilador no sabía que [System.exit] nunca devuelve el control, por lo que había que añadir una instrucción [return] redundante después de ella;
  • línea 17: terminación con el código de retorno pasado como argumento. La línea siguiente no se ejecuta. El compilador de Kotlin 2.4 la acepta sin advertencia; IntelliJ IDEA la marca como “unreachable code” (código inalcanzable);
  • Resultados: el comando [echo $?] muestra el código de retorno del último programa ejecutado: 3, y luego 1 en ambos casos de error.

3.5.2. Estructura de decisión simple

1
2
3
4
5
if (condition) {
    actions_condition_true
} else {
    actions_condition_false
}

Notas:

  • la condición se escribe entre paréntesis. Debe ser de tipo [Boolean]: al igual que Java, y a diferencia del lenguaje C, Kotlin rechaza [if (n)] cuando [n] es un entero;
  • las acciones no terminan con punto y coma: en Kotlin, el fin de línea termina la instrucción. El punto y coma solo se usa para escribir varias instrucciones en una sola línea;
  • las llaves solo son obligatorias si hay más de una instrucción; sin embargo, a menudo se utilizan incluso para una sola instrucción, por legibilidad y para evitar errores al agregar una instrucción. Como en Java, la convención es colocar la llave de apertura al final de la línea;
  • la cláusula [else] puede omitirse;
  • no existe la palabra clave [then].

El equivalente algorítmico de esta estructura es la estructura si...entonces...si no:

1
2
3
4
if condition
    then actions_condition_true
    else actions_condition_false
endif

Ejemplo:

if (x > 0) { nx = nx + 1; sx = sx + x } else dx = dx - x

La principal diferencia con Java es que el [if] de Kotlin es también una expresión: devuelve el valor de la rama ejecutada. Por lo tanto, podemos escribir [val max = if (a > b) a else b]. Por eso Kotlin no tiene un operador ternario [condition ? value1 : value2]: el [if] sirve como su equivalente. Cuando se usa como expresión, [if] debe tener una cláusula [else]; de lo contrario, no tendría valor cuando la condición es falsa.

Las estructuras de decisión pueden anidarse. Esto plantea a veces el problema que ilustra el programa [Basics17.kt]:

// estructura de decisión simple if
package basics17

fun main() {
    val n = 5
    // un else siempre se refiere al if más cercano
    if (n > 1)
        if (n > 6)
            println(">6")
        else
            println("<=6")

    // con llaves, el else se asocia al primer if
    val n2 = 0
    if (n2 > 1) {
        if (n2 > 6) {
            println(">6")
        }
    } else {
        println("<=1")
    }

    // una secuencia de decisiones: else if
    val grade = 13
    val honours: String
    if (grade < 10) {
        honours = "failed"
    } else if (grade < 12) {
        honours = "pass"
    } else if (grade < 14) {
        honours = "fairly good"
    } else {
        honours = "good"
    }
    println("grade=$grade, honours=$honours")

    // if es una expresión: devuelve el valor de la rama ejecutada
    val grade2 = 8
    val honours2 = if (grade2 < 10) "failed" else if (grade2 < 12) "pass" else "at least fairly good"
    println("grade=$grade2, honours=$honours2")
    // el equivalente del operador ternario de Java (n > 0 ? "positive" : "negative or zero")
    println("$n is ${if (n > 0) "positive" else "negative or zero"}")
    // una rama puede ser un bloque: su valor es el de su última expresión
    val max = if (n > n2) {
        println("the largest is n")
        n
    } else {
        println("the largest is n2")
        n2
    }
    println("max=$max")
}

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=basics17.Basics17Kt
<=6
<=1
grade=13, honours=fairly good
grade=8, honours=failed
5 is positive
the largest is n
max=5

Comentarios:

  • líneas 7–11: ¿a qué [if] se refiere el [else] de la línea 10? La regla es que un [else] siempre se refiere al [if] más cercano: [if (n > 6)], línea 8. La sangría del código, que no tiene efecto para el compilador, se eligió para ilustrarlo;
  • líneas 15–20: aquí se quería colocar un [else] junto a [if (n2 > 1)], y no un [else] junto a [if (n2 > 6)]. Debido a la regla anterior, estamos obligados a colocar llaves alrededor de [if (n2 > 1) { ... }];
  • líneas 26–33: una secuencia de opciones mutuamente excluyentes se escribe mediante instrucciones [else if] sucesivas. Las condiciones se prueban en orden; la primera que se evalúa como verdadera determina la acción que se ejecuta. La variable [honours] se declara como [val] sin valor en la línea 25: el compilador verifica que se le asigne un valor (una sola vez) en cada rama antes de usarla en la línea 35. En la sección siguiente veremos una forma más concisa de escribir esta secuencia de opciones;
  • línea 39: [if] se usa como expresión. Su valor (la cadena seleccionada) se asigna a [honours2]. Esto evita declarar la variable sin valor;
  • línea 42: [if] reemplaza el operador ternario de Java, aquí dentro de una plantilla de cadena [${...}];
  • líneas 44–49: cuando una rama es un bloque, su valor es el de la última expresión del bloque: [n] para la primera rama, [n2] para la segunda. Las instrucciones anteriores se ejecutan normalmente.

3.5.3. Estructura de casos

3.5.3.1. La instrucción when

Kotlin no tiene la instrucción [switch]. La reemplaza con la instrucción [when], que es más simple y más potente. Su sintaxis es la siguiente:

1
2
3
4
5
6
when (expression) {
    v1 -> actions1
    v2, v3 -> actions2
    ...
    else -> actions_otherwise
}

Notas:

  • La expresión de control se escribe entre paréntesis. Puede ser de cualquier tipo: un entero, un carácter, una cadena, un valor de enumeración, así como [Long], [Double], [Boolean] o cualquier objeto. Los valores se comparan con el operador [==], es decir, con el método [equals];
  • cada cláusula asocia uno o más valores, separados por comas, con una acción. La acción, colocada después de la flecha [->], es una sola instrucción o un bloque entre llaves;
  • los valores vi no son necesariamente constantes: pueden ser expresiones cualesquiera, evaluadas en el orden de las cláusulas;
  • solo se ejecuta la acción de la primera cláusula cuyo valor coincide: no es necesario escribir [break], ni hay encadenamiento de una cláusula a la siguiente. El error clásico de la sintaxis histórica [switch] de Java (olvidar el [break]) es, por lo tanto, imposible. Así funciona la sintaxis con flecha introducida en Java 14, que es la única forma utilizada en Kotlin;
  • la cláusula [else], equivalente al [default] de Java, puede omitirse cuando [when] se usa como instrucción.

Ejemplo algorítmico:

depending on the value of choice
    case 0
        end of the module
    case 1
        execute module M1
    case 2
        execute module M2
    otherwise
        error <- true
endcase

3.5.3.2. La expresión when y sus diversas cláusulas

Muy a menudo, una estructura de casos se usa únicamente para seleccionar un valor. Al igual que [if], [when] puede usarse como expresión con este fin:

1
2
3
4
5
6
result = when (expression) {
    v1 -> value1
    v2, v3 -> value2
    ...
    else -> value_otherwise
}

La expresión [when] debe ser exhaustiva: debe especificar un valor para todos los valores posibles de la expresión de control, lo que generalmente requiere una cláusula [else]. Sin ella, el compilador rechaza el programa:

error: 'when' expression must be exhaustive. Add an 'else' branch.

La cláusula [else] solo es innecesaria cuando el compilador puede verificar por sí mismo que se manejan todos los valores: para una expresión de tipo [Boolean] ([true] y [false]), una enumeración (todas sus constantes; véase la sección sobre enumeraciones más adelante) o una clase sellada (capítulo 4). Cuando una cláusula requiere varias instrucciones, se escribe un bloque, cuyo valor es el de su última expresión. No existe un equivalente a la instrucción [yield] de Java.

En lugar de un valor, una cláusula puede contener:

  • una prueba de pertenencia [in range]: [in 1..10 -> "small"] se evalúa si la expresión está entre 1 y 10. Se escribe [!in] para la no pertenencia;
  • una prueba de tipo [is Type]: [is String -> ...] se selecciona si el objeto examinado es de tipo [String]. En la acción, el objeto se trata entonces automáticamente como un [String] (conversión inteligente de tipos): no es necesario introducir una nueva variable, como en el [case String s] de Java. [!is] comprueba que un objeto no es de un tipo determinado;
  • una guarda: desde Kotlin 2.2, una cláusula puede complementarse con una condición introducida por [if]: [is Int if o > 0 -> ...] solo se evalúa para un entero positivo. Equivale a las guardas [when] de Java 21.

Por último, [when] puede usarse sin argumento. En este caso, cada cláusula es una condición booleana cualquiera, y se selecciona la primera condición verdadera. Es una forma más legible de escribir una secuencia de cláusulas [if ... else if].

Las cláusulas se evalúan en orden: se selecciona la primera que cumple la condición. A diferencia del [switch] de Java, el [when] de Kotlin maneja tanto los tipos primitivos ([Int], [Double]...) como los objetos: no hace falta pasar por un [Integer] para clasificar un entero con guardas.

El programa [Basics18.kt] es el siguiente:

// estructura de casos: when, instrucción y expresión
package basics18

fun main() {
    val choice = 2
    var error = false
    when (choice) {
        0 -> return
        1 -> m1()
        2 -> m2()
        else -> error = true
    }
    println("error=$error")

    // varios valores para el mismo caso, expresión de tipo String
    val day = "saturday"
    when (day) {
        "saturday", "sunday" -> println("$day : weekend")
        else -> println("$day : weekday")
    }

    // when también es una expresión: devuelve un valor
    val dayType = when (day) {
        "saturday", "sunday" -> "weekend"
        "monday", "tuesday", "wednesday", "thursday", "friday" -> "weekday"
        else -> "unknown day"
    }
    println("$day : $dayType")
    // el valor de un bloque es el de su última expresión
    val nbHours = when (day) {
        "saturday" -> 4
        "sunday" -> 0
        else -> {
            val hours = 7
            hours + 1
        }
    }
    println("$day : $nbHours opening hour(s)")

    // when con rangos
    println("-5 : ${classify(-5)}")
    println("0 : ${classify(0)}")
    println("7 : ${classify(7)}")
    println("42 : ${classify(42)}")
    println("1000 : ${classify(1000)}")
    // when sin argumento: una secuencia de condiciones
    val grade = 13
    val honours = when {
        grade < 10 -> "failed"
        grade < 12 -> "pass"
        grade < 14 -> "fairly good"
        else -> "good"
    }
    println("grade=$grade, honours=$honours")
    // coincidencia según el tipo del objeto
    val objects = arrayOf<Any?>(12, -3, "kotlin", 2.5, null)
    for (o in objects) {
        println("$o : ${describe(o)}")
    }
}

// funciones utilizadas anteriormente
fun m1() {
    println("M1")
}

fun m2() {
    println("M2")
}

fun classify(n: Int): String = when (n) {
    in Int.MIN_VALUE..<0 -> "negative"
    0 -> "zero"
    in 1..10 -> "small"
    in 11..99 -> "medium"
    else -> "large"
}

fun describe(o: Any?): String = when (o) {
    null -> "no object"
    is Int if o > 0 -> "positive integer"
    is Int -> "negative or zero integer"
    is String -> "string of ${o.length} characters"
    else -> "object of type ${o::class.simpleName}"
}

Resultados:

> gradlew -q run -Pmain=basics18.Basics18Kt
M2
error=false
saturday : weekend
saturday : weekend
saturday : 4 opening hour(s)
-5 : negative
0 : zero
7 : small
42 : medium
1000 : large
grade=13, honours=fairly good
12 : positive integer
-3 : negative or zero integer
kotlin : string of 6 characters
2.5 : object of type Double
null : no object

Comentarios:

  • líneas 7–11: la implementación en Kotlin del algoritmo anterior. Una cláusula puede contener una asignación cuando [when] se usa como instrucción;
  • línea 8: [return] termina la función [main]y, por lo tanto, el programa;
  • línea 18: dos valores para las mismas acciones, separados por una coma;
  • líneas 23–26: una expresión [when] sobre una cadena. La cláusula [else] la hace exhaustiva;
  • líneas 30–35: una cláusula cuya acción es un bloque: el valor de la última expresión del bloque, [hours + 1] (línea 35), es el valor de la expresión [when];
  • líneas 71–76: la función [classify] clasifica un entero mediante intervalos. [Int.MIN_VALUE..<0] es el intervalo de enteros que va desde el [Int] más pequeño hasta 0 excluido, es decir, los enteros negativos; [1..10] contiene los enteros del 1 al 10 inclusive. La constante 0 se incluye entre los intervalos. La cláusula [else] maneja los valores restantes, en este caso los enteros mayores o iguales que 100. El cuerpo de la función es una expresión, escrita después del signo [=]: volveremos sobre estas funciones con cuerpo de expresión más adelante;
  • líneas 48–52: un [when] sin argumentos, que reescribe la secuencia de [else if] del programa [Basics17.kt]: la primera condición verdadera asigna su valor a la expresión;
  • línea 56: un arreglo de objetos de tipos diferentes. El tipo de sus elementos, [Any?] (cualquier objeto, o [null]), se especifica explícitamente: sin ello, el compilador inferiría un tipo complejo a partir de los valores y rechazaría el programa (“type argument for reified type parameter 'T' was inferred to the intersection of ['Comparable<*>?' & 'Serializable?']”);
  • líneas 79–84: la función [describe] selecciona según el tipo del objeto. En la línea 80, el valor [null] es simplemente otro valor para [when]. En la línea 81, la guarda [if o > 0] puede comparar [o] con 0 porque, después de la prueba [is Int], [o] se trata como un [Int]. De igual forma, en la línea 83, la propiedad [length] de la cadena puede usarse sin conversión. La cláusula sin guarda, [is Int] (línea 82), debe colocarse después de la cláusula con guarda, a la que ocultaría en caso contrario. En la línea 84, [o::class.simpleName] proporciona el nombre simple de la clase del objeto: [Double];
  • líneas 63–68: dos funciones llamadas por la primera, [when].

La siguiente tabla resume las correspondencias entre los dos lenguajes:

Java
Kotlin
[switch (x) { case 1: ... break; default: ... }]
[when (x) { 1 -> ... ; else -> ... }]
[case "saturday", "sunday" -> ...]
["saturday", "sunday" -> ...]
[default -> ...]
[else -> ...]
[yield value;]
última expresión del bloque
[case Integer i when i > 0 -> ...]
[is Int if x > 0 -> ...]
[case null -> ...]
[null -> ...]
(sin equivalente)
[in 1..10 -> ...]
cadena de [if ... else if]
[when { condition -> ... }]

3.5.4. Estructuras de repetición

3.5.4.1. Número conocido de repeticiones

Estructura for

Kotlin no tiene el bucle “de tres argumentos” de C y Java ([for (i = id; i <= if; i = i + ip)]). Su bucle [for] recorre los elementos de un intervalo, un arreglo o una colección; es el equivalente del bucle for-each de Java. Para iterar sobre un entero, se recorre un intervalo:

1
2
3
for (i in id..if step ip) {
    actions
}

Notas:

  • [id..if] es el intervalo de enteros desde [id] hasta [if], ambos inclusive. [step ip] establece el paso de la secuencia; es opcional y su valor predeterminado es 1;
  • [id..<if], que también puede escribirse como [id until if], es el intervalo desde [id] hasta [if], excluyendo el extremo superior. Es cómodo para recorrer los índices de un arreglo de [n] elementos: [for (i in 0..<n)];
  • [if downTo id] es la secuencia descendente desde [if] hasta [id];
  • la variable de bucle [i] se declara mediante [for], sin [val] ni [var]: solo existe dentro del bucle y no puede modificarse dentro del cuerpo del bucle;
  • las llaves solo son necesarias si hay más de una acción.

El equivalente algorítmico es la estructura “para”:

1
2
3
for i varying from id to if in steps of ip
    actions
endfor

que puede traducirse a una estructura "mientras":

1
2
3
4
5
i <- id
while i <= if
    actions
    i <- i + ip
endwhile

Los intervalos no son una sintaxis específica del bucle [for]: son objetos ([IntRange], [IntProgression], [CharRange]...) que pueden asignarse a una variable, pasarse a una función, evaluarse mediante el operador [in] ([if (x in 1..10)], como en [when]) o manipularse mediante funciones de la biblioteca estándar ([(1..10).sum()]). También existen intervalos de caracteres: ['a'..'z'].

Bucle for sobre un arreglo o una colección

La sintaxis es la siguiente:

1
2
3
for (variable in collection) {
    instructions
}

Notas:

  • [collection] es un arreglo o una colección de objetos iterables (en realidad, cualquier objeto que tenga una función [iterator()]). Trataremos las colecciones ([List], [Set], [Map]...) en el capítulo 5;
  • el tipo de *[variable]* se infiere del tipo de los elementos de la colección: no se especifica explícitamente;
  • [variable] es una variable local del bucle que tomará sucesivamente todos los valores de la colección. Es de solo lectura, como si estuviera declarada con [val]: no se le puede asignar otro valor dentro del bucle;
  • Para recorrer los índices de un arreglo, se usa su propiedad [indices]: [for (i in array.indices)]; para obtener a la vez el índice y el elemento, se usa la función [withIndex()]: [for ((i, element) in array.withIndex())].

La función repeat

Cuando se quiere ejecutar un bloque de instrucciones exactamente [n] veces, la función [repeat] de la biblioteca estándar es la forma más simple:

1
2
3
repeat(n) {
    instructions
}

Dentro del bloque, el nombre [it] denota el número de la iteración actual, que va de 0 a n-1. Este bloque es en realidad una lambda, una función anónima que se pasa como parámetro a la función [repeat]: trataremos las lambdas en el capítulo 7.

3.5.4.2. Número desconocido de iteraciones

Bucle while

1
2
3
while (condition) {
    actions
}

El bucle continúa mientras la condición sea verdadera. Puede que el bucle no se ejecute nunca. Las notas son las mismas que para [for]. La estructura algorítmica correspondiente es la estructura mientras:

1
2
3
while condition
    actions
endwhile

Bucle "do while"

La sintaxis es la siguiente:

1
2
3
do {
    instructions
} while (condition)

El bucle continúa hasta que la condición se evalúa como falsa. Aquí, el bucle se ejecuta al menos una vez. Una particularidad de Kotlin: una variable declarada dentro del cuerpo del bucle es visible en la condición del [while], lo que permite escribir [do { val line = readln() } while (line != "end")]. La estructura algorítmica correspondiente es la estructura "repetir...hasta que":

1
2
3
repeat
    actions
until not condition

No existe estructura para el bucle "general"

El bucle Java [for (start_instructions; condition; end_of_loop_instructions)] no existe en Kotlin. Cuando un intervalo no basta, escribimos el bucle equivalente [while]:

1
2
3
4
5
start_instructions
while (condition) {
    instructions
    end_of_loop_instructions
}

3.5.4.3. Instrucciones de control de bucles

Instrucción
Función
[break]
Sale del bucle [for], [while], [do ... while]
[continue]
pasa a la siguiente iteración de los bucles [for], [while], [do ... while]
[break@label]
Sale del bucle precedido por la etiqueta [label@], incluso si la instrucción se encuentra dentro de un bucle anidado
[continue@label]
avanza a la siguiente iteración del bucle precedido por la etiqueta [label@]

Una etiqueta es un identificador seguido del carácter [@], colocado antes del bucle: [search@ for (...)]. Se la referencia, sin espacio, después de [break] o [continue]: [break@search]. En Java, la etiqueta iba seguida de dos puntos ([search:]).

3.5.4.4. Ejemplos

El programa [Basics19.kt] es el siguiente:

// estructuras de repetición
package basics19

fun main() {
    // cuatro maneras de calcular la suma de los primeros 10 enteros
    val n = 10
    var sum = 0
    for (i in 1..n) {
        sum += i
    }
    println("for : sum=$sum")

    var i = 1
    sum = 0
    while (i <= n) {
        sum += i
        i++
    }
    println("while : sum=$sum")

    i = 1
    sum = 0
    do {
        sum += i++
    } while (i <= n)
    println("do while : sum=$sum")

    // la biblioteca estándar puede calcular la suma de los elementos de un rango
    println("sum : sum=${(1..n).sum()}")

    // rangos y progresiones
    var product = 1
    for (k in 1..5) {
        product *= k
    }
    println("5! = $product")
    for (k in 0..<5) print("$k ")    // 5 excluido (también se escribe 0 until 5)
    println()
    for (k in 10 downTo 0 step 2) print("$k ")
    println()
    for (c in 'a'..'e') print(c)
    println()
    // repeat: repite un bloque n veces; it es el número de la repetición (0, 1, ...)
    repeat(3) {
        print("[round $it] ")
    }
    println()

    // iteración sobre los elementos de un arreglo o de una colección
    val friends = arrayOf("paul", "hélène", "jacques", "sylvie")
    for (name in friends) {
        println(name)
    }
    // a través de los índices
    for (j in friends.indices) {
        print("${friends[j].length} ")
    }
    println()
    // elementos e índices al mismo tiempo
    for ((j, name) in friends.withIndex()) {
        println("friends[$j]=$name")
    }

    // break y continue
    for (k in 1..10) {
        // los números pares se omiten
        if (k % 2 == 0) {
            continue
        }
        // nos detenemos después de 7
        if (k > 7) {
            break
        }
        print("$k ")
    }
    println()

    // bucle infinito del que se sale con break: el primer múltiplo de 7 mayor que 50
    var multiple = 50
    while (true) {
        multiple++
        if (multiple % 7 == 0) {
            break
        }
    }
    println("first multiple of 7 greater than 50: $multiple")

    // break con etiqueta: salimos de ambos bucles a la vez
    val grid = arrayOf(intArrayOf(1, 2, 3), intArrayOf(4, -5, 6), intArrayOf(7, 8, 9))
    search@ for (row in grid.indices) {
        for (column in grid[row].indices) {
            if (grid[row][column] < 0) {
                println("first negative at [$row][$column]")
                break@search
            }
        }
    }
}

Resultados:

> gradlew -q run -Pmain=basics19.Basics19Kt
for : sum=55
while : sum=55
do while : sum=55
sum : sum=55
5! = 120
0 1 2 3 4
10 8 6 4 2 0
abcde
[round 0] [round 1] [round 2]
paul
hélène
jacques
sylvie
4 6 7 6
friends[0]=paul
friends[1]=hélène
friends[2]=jacques
friends[3]=sylvie
1 3 5 7
first multiple of 7 greater than 50: 56
first negative at [1][1]

Comentarios:

  • líneas 6–29: cuatro maneras de calcular la suma de los primeros 10 enteros;
  • líneas 8–11: el bucle [for] recorre el intervalo [1..n], incluido el 10. La variable de bucle [i] solo existe dentro del bucle: la variable [i] declarada en la línea 13 es una variable diferente;
  • líneas 15–17: el bucle [while] equivalente: la inicialización, la verificación de la condición y el incremento de [i] se escriben explícitamente. Esta es la traducción a Kotlin de un bucle Java [for] general;
  • línea 24: [i++] devuelve el valor de [i] antes de incrementarlo: [i] se suma a [sum], y luego [i] se incrementa. Los operadores [++] y [--] existen tanto en Kotlin como en Java;
  • línea 29: el intervalo [1..n] es un objeto; su función [sum()] devuelve la suma de sus elementos. Esta es la forma más idiomática de escribirlo en Kotlin. Los paréntesis alrededor del intervalo son necesarios: la llamada a función tiene precedencia sobre el operador [..];
  • líneas 33–36: el cálculo de 5! = 1 × 2 × 3 × 4 × 5;
  • línea 37: un intervalo cuyo límite superior está excluido: [k] va de 0 a 4. Cuando el cuerpo del bucle consta de una sola instrucción, puede escribirse en la misma línea que el [for];
  • línea 39: una secuencia descendente, de 10 a 0, con un paso de 2;
  • línea 41: un intervalo de caracteres;
  • líneas 44–45: el bloque se ejecuta 3 veces; [it] toma sucesivamente los valores 0, 1 y 2;
  • líneas 51–52: el bucle [for] recorre los elementos del arreglo [friends];
  • líneas 55–56: [friends.indices] es el intervalo de índices del arreglo, que en este caso es [0..3] . Se muestra la longitud de cada nombre;
  • líneas 60–61: [friends.withIndex()] devuelve tuplas (índice, elemento). La sintaxis [(j, name)] las descompone en dos variables: es una asignación de desestructuración, sobre la que volveremos al final de este capítulo;
  • líneas 65–74: [continue] pasa a la siguiente iteración para los números pares; [break] detiene el bucle en cuanto [k] supera 7;
  • líneas 80–86: un bucle infinito [while (true)], del que se sale mediante [break]. Esta forma es cómoda cuando la condición de terminación se calcula en medio del bucle. La usaremos para la entrada por teclado;
  • líneas 89–94: búsqueda del primer número negativo en un arreglo bidimensional, un arreglo de arreglos de enteros ([IntArray]). La etiqueta [search@] (línea 90) da nombre al bucle exterior; la instrucción [break@search] (línea 94) sale de ambos bucles a la vez. Un simple [break] saldría solo del bucle interior. Kotlin no tiene una instrucción [goto]: las etiquetas cumplen esta función en este caso específico.

3.6. Manejo de excepciones

Muchas funciones de Kotlin y Java pueden lanzar excepciones, es decir, errores. Cuando una función puede lanzar una excepción, el programador debe manejarla para que los programas toleren mejor los errores: siempre se debe evitar la terminación abrupta de una aplicación.

3.6.1. La estructura try/catch/finally

El manejo de excepciones sigue este patrón:

1
2
3
4
5
6
try {
    code likely to throw an exception
} catch (e: Exception) {
    handle the exception e
}
next statement

Si el código del bloque [try] no lanza una excepción, la ejecución continúa con la instrucción siguiente; de lo contrario, continúa con el cuerpo del bloque [catch] y luego con la instrucción siguiente. Observe los puntos siguientes:

  • [e] es un objeto de tipo [Exception] o de un tipo derivado. Como en toda declaración de Kotlin, el nombre precede al tipo: [e: Exception]. Existen muchos tipos de excepciones: [ArrayIndexOutOfBoundsException], [NumberFormatException], [ArithmeticException], [IllegalArgumentException], [IllegalStateException], [NullPointerException], [IOException], etc. Son clases de excepciones de Java que Kotlin utiliza directamente (las más comunes también están disponibles en el paquete [kotlin] con el mismo nombre, sin [import]). Al escribir [catch (e: Exception)], se indica que se desea manejar todos los tipos de excepciones. Si es probable que el código de la cláusula [try] genere varios tipos de excepciones, conviene ser más específico y manejar la excepción con varias cláusulas [catch]:
1
2
3
4
5
6
7
8
try {
    code likely to throw the exceptions
} catch (e1: ArrayIndexOutOfBoundsException) {
    handle the exception e1
} catch (e2: NumberFormatException) {
    handle the exception e2
}
next statement

Las cláusulas [catch] se evalúan en orden; se ejecuta la primera cuyo tipo coincide con la excepción. Por lo tanto, una cláusula que maneja un tipo de excepción específico debe preceder a la que maneja un tipo más general. Nota: a diferencia del compilador de Java, el compilador de Kotlin no rechaza una cláusula que nunca podría alcanzarse; corresponde al programador asegurarse de ello (volveremos sobre esto);

  • Kotlin no tiene la cláusula [catch] múltiple de Java ([catch (IOException | NumberFormatException e)]). Se pueden escribir varias cláusulas, o una sola cláusula para un tipo más general en la que se prueba el tipo de la excepción, por ejemplo con un [when];
  • Se puede agregar una cláusula [finally] a las cláusulas [try / catch]:
1
2
3
4
5
6
7
8
try {
    code likely to throw an exception
} catch (e: Exception) {
    handle the exception e
} finally {
    code executed after try or catch
}
next statement

Ocurra o no una excepción, el código de la cláusula [finally] siempre se ejecuta. Normalmente, aquí se cierra un archivo; veremos que existe una forma más sencilla de hacerlo, mediante la función [use];

  • en la cláusula [catch], es posible que no se quiera utilizar el objeto de la excepción. En ese caso, se lo puede nombrar _: [catch (_: NumberFormatException)], donde el carácter _ designa una variable anónima que no se usará;
  • Una excepción tiene una propiedad llamada [message] (el equivalente del método [getMessage()] de Java) que contiene el mensaje con el detalle del error ocurrido. Es de tipo [String?]: algunas excepciones no tienen mensaje. Para mostrarlo, se escribe:
1
2
3
4
} catch (ex: Exception) {
    System.err.println("The following error occurred: ${ex.message}")
    ...
}
  • El método [toString()] de una excepción devuelve el nombre completo de su clase seguido de su mensaje; su método [printStackTrace()] muestra además la pila de llamadas (es decir, la lista de funciones que se estaban ejecutando en el momento del error), junto con el nombre del archivo fuente y el número de línea. Es la información más útil para el desarrollador, pero no está destinada al usuario. En este curso, mostraremos casi siempre el nombre de la clase de la excepción ([ex.javaClass.name] o [ex.javaClass.simpleName]) y su mensaje. [ex.javaClass] es la clase Java del objeto, la que devuelve el método [getClass()] en Java;
  • Por último, y esta es una diferencia importante con Java, [try] es una expresión: su valor es el de la última expresión del bloque [try] si no ocurre ninguna excepción, y el de la última expresión del bloque [catch] si ocurre una excepción. La cláusula [finally] no afecta este valor. Por lo tanto, se puede escribir [val n = try { text.toInt() } catch (_: NumberFormatException) { 0 }].

3.6.2. Un primer ejemplo

El programa [Basics20.kt] muestra una excepción generada al usar un elemento de arreglo inexistente:

// una excepción causada por un índice de arreglo incorrecto
package basics20

fun main() {
    val tab = intArrayOf(0, 1, 2, 3)
    // mostrar el arreglo con sus índices
    for (i in tab.indices) {
        println("tab[$i]=${tab[i]}")
    }
    // mostrar los elementos del arreglo
    for (elmt in tab) {
        println(elmt)
    }
    // generar una excepción
    try {
        tab[100] = 6
    } catch (e: Exception) {
        System.err.println("The following error occurred: ${e.javaClass.name} - ${e.message}")
        return
    } finally {
        println("finally ...")
    }
    println("This line is not executed")
}

Resultados:

> gradlew -q run -Pmain=basics20.Basics20Kt
tab[0]=0
tab[1]=1
tab[2]=2
tab[3]=3
0
1
2
3
The following error occurred: java.lang.ArrayIndexOutOfBoundsException - Index 100 out of bounds for length 4
finally ...

Comentarios:

  • línea 16: esta instrucción lanza una excepción porque el arreglo [tab] no tiene ningún elemento en el índice 100. El compilador no verifica los índices, ni siquiera los constantes: el error solo se detecta en tiempo de ejecución, por la máquina virtual de Java;
  • línea 17: la cláusula [catch (e: Exception)] captura todas las excepciones;
  • línea 18: la excepción es de tipo [java.lang.ArrayIndexOutOfBoundsException], y su mensaje indica el índice incorrecto y el tamaño del arreglo (penúltima línea de los resultados);
  • línea 19: se sale de la función [main] y, por lo tanto, del programa;
  • líneas 20–21: la cláusula [finally] se ejecutó (última línea de los resultados), aunque la cláusula [catch] contenía una instrucción [return]. Observe que la cláusula [finally] siempre se ejecuta;
  • línea 23: debido a [return], esta línea no se ejecuta.

3.6.3. Una entrada controlada

Veamos otro ejemplo, [Basics21.kt], en el que se maneja la excepción causada por convertir en entero una cadena que no representa un entero:

// ingreso de una edad con manejo de la excepción de conversión
package basics21

fun main() {
    // pedimos el nombre
    print("Name: ")
    val name = readlnOrNull() ?: ""
    // pedimos la edad
    var age = 0
    var ageOK = false
    while (!ageOK) {
        // pregunta, lectura y verificación de la respuesta
        print("age: ")
        try {
            age = readln().toInt()
            ageOK = age >= 1
        } catch (_: NumberFormatException) {
            // ageOK sigue siendo false
        }
        if (!ageOK) {
            println("Incorrect age, try again...")
        }
    }
    // visualización final
    println("Your name is $name and you are $age year(s) old")

    // la misma entrada con un try usado como expresión
    var age2: Int
    while (true) {
        print("age: ")
        // el valor del try es el del bloque try, o el del bloque catch en caso de excepción
        age2 = try {
            readln().toInt()
        } catch (_: NumberFormatException) {
            0
        }
        if (age2 >= 1) break
        println("Incorrect age, try again...")
    }
    println("Your name is $name and you are $age2 year(s) old")
}

Resultados (las entradas, escritas con el teclado, se han insertado en la salida):

1
2
3
4
5
6
> gradlew -q run -Pmain=basics21.Basics21Kt
Name: dupont
age: 23
Your name is dupont and you are 23 year(s) old
age: 23
Your name is dupont and you are 23 year(s) old
> gradlew -q run -Pmain=basics21.Basics21Kt
Name: durand
age: x
Incorrect age, try again...
age: -4
Incorrect age, try again...
age: 99999999999
Incorrect age, try again...
age: 12
Your name is durand and you are 12 year(s) old
age: abc
Incorrect age, try again...
age: 7
Your name is durand and you are 7 year(s) old

Comentarios:

  • línea 7: si el flujo de entrada está cerrado, [readlnOrNull] devuelve [null]: el operador [?:] lo reemplaza por una cadena vacía;
  • Líneas 11–21: el bucle de entrada de la edad;
  • línea 15: la línea escrita con el teclado se convierte en entero mediante la función [toInt]. Esta función lanza una excepción [NumberFormatException] si la conversión no es posible. Por eso la operación se colocó dentro de un [try / catch]. En cambio, la función [readln] lanza una excepción si el flujo de entrada está cerrado: no capturamos esta excepción, ya que hacerlo provocaría que el programa termine;
  • línea 16: si se llega a esta línea, significa que la conversión fue exitosa. Sin embargo, se verifica que el entero obtenido sea efectivamente mayor o igual que 1;
  • línea 17: si se lanza una excepción [NumberFormatException], se pasa a [catch], donde no se hace nada. Así, la variable booleana [ageOK], inicializada en [false], permanece en [false]. La variable de la excepción, que no se usa, es la variable anónima _. Solo se captura la excepción esperada: una cláusula [catch (_: Exception)] también enmascararía errores que no se habían previsto;
  • líneas 20–21: se muestra un mensaje de error si la edad es incorrecta;
  • líneas 28–40: la misma entrada, escrita con un [try] como expresión. Si la conversión tiene éxito, el valor de [try] es el entero obtenido; de lo contrario, es el valor del bloque [catch], 0, que será rechazado por la prueba de la línea 37. El bucle infinito [while (true)], del que se sale mediante [break], evita la variable booleana [ageOK]. El compilador sabe que solo se sale del bucle después de haber asignado un valor a [age2]; por lo tanto, permite su uso en la línea 40, aunque se haya declarado sin valor.

Un número demasiado grande para un [Int] (como 99999999999) también provoca una [NumberFormatException]: por lo tanto, se maneja como las demás entradas no válidas (segunda ejecución).

Usar una excepción para validar una entrada es una práctica común en Java, pero Kotlin ofrece una solución mejor: la función [toIntOrNull()], presentada al comienzo de este capítulo, devuelve [null] en lugar de lanzar una excepción. Entonces escribiríamos [val age = readln().toIntOrNull()] seguido de [if (age != null && age >= 1)], sin [try]. Esto es lo que haremos en la aplicación de ejemplo que sigue. Las excepciones deben reservarse para situaciones excepcionales.

3.6.4. Varias cláusulas catch y lanzamiento de excepciones

El propio programa puede lanzar una excepción mediante la instrucción [throw]:

throw IllegalArgumentException("error message")

En Kotlin no existe el operador [new]: un objeto se crea simplemente llamando al constructor de su clase. La ejecución de la función actual se detiene y la excepción se propaga a través de las funciones que realizaron la llamada hasta que una cláusula [catch] la maneja; si ninguna lo hace, el programa termina y muestra la excepción y la pila de llamadas. En una cláusula [catch], la instrucción [throw e] vuelve a lanzar la excepción actual, por ejemplo después de registrarla.

En Kotlin, [throw] es una expresión de tipo [Nothing] (como [exitProcess]). Por lo tanto, puede usarse dondequiera que se espere un valor, por ejemplo después del operador [?:]: [val name = input ?: throw IllegalArgumentException("missing name")].

Kotlin, al igual que Java, no ofrece un filtro para las cláusulas [catch]: para manejar una excepción solo en ciertos casos, se prueba la condición dentro de la cláusula y, de ser necesario, se vuelve a lanzar la excepción.

Para las verificaciones más comunes, la biblioteca estándar de Kotlin proporciona funciones que lanzan la excepción por nosotros:

Función
Rol
[require(condition) { message }]
verifica un argumento: lanza una [IllegalArgumentException] con el mensaje calculado por el bloque si la condición es falsa
[requireNotNull(value) { message }]
lanza una [IllegalArgumentException] si [value] es igual a [null]; de lo contrario, devuelve el valor como un tipo no nulable. Equivale al método [Objects.requireNonNull] de Java, que a su vez lanza una [NullPointerException]
[check(condition) { message }]
verifica una condición: lanza una [IllegalStateException] si la condición es falsa
[checkNotNull(value) { message }]
lanza una [IllegalStateException] si [value] es igual a [null]y, de lo contrario, devuelve el valor
[error(message)]
siempre lanza una [IllegalStateException]; de tipo [Nothing], se usa para señalar un caso que no debería ocurrir

El mensaje se genera mediante un bloque (una lambda) que se ejecuta solo si la verificación falla: no se calcula una cadena innecesariamente cuando todo está bien.

El programa [Basics22.kt] ilustra estas posibilidades:

// varias cláusulas catch, lanzamiento de excepciones
package basics22

fun main() {
    val inputs = arrayOf("12", "abc", "", "99999999999", "-3", "150")
    for (input in inputs) {
        try {
            val age = readAge(input)
            println("[$input] : age=$age")
        } catch (e: NumberFormatException) {
            // no hay filtro en una cláusula catch: se prueba dentro de la cláusula
            if (input.isEmpty()) {
                println("[$input] : empty input")
            } else {
                println("[$input] : ${e.javaClass.simpleName} - ${e.message}")
            }
        } catch (e: IllegalArgumentException) {
            println("[$input] : ${e.javaClass.simpleName} - ${e.message}")
        }
    }

    // require, requireNotNull, check, error: verificaciones que lanzan excepciones
    val names = arrayOf("dupont", null)
    for (name in names) {
        try {
            val valid = requireNotNull(name) { "the name is mandatory" }
            println("name=$valid")
        } catch (e: IllegalArgumentException) {
            println("${e.javaClass.simpleName} - ${e.message}")
        }
    }
    for (input in arrayOf("45", "200")) {
        try {
            println("age=${readAge2(input)}")
        } catch (e: IllegalArgumentException) {
            println("${e.javaClass.simpleName} - ${e.message}")
        }
    }
    for (state in arrayOf("open", "closed", "broken")) {
        try {
            println("$state : ${process(state)}")
        } catch (e: IllegalStateException) {
            println("$state : ${e.javaClass.simpleName} - ${e.message}")
        }
    }
}

// una función que lanza excepciones
fun readAge(text: String): Int {
    // toInt lanza NumberFormatException
    val age = text.toInt()
    // lanzamos una excepción nosotros mismos si la edad está fuera de los límites
    if (age < 0 || age > 130) {
        throw IllegalArgumentException("age out of bounds [0,130] : $age")
    }
    return age
}

// la misma verificación con require
fun readAge2(text: String): Int {
    val age = text.toInt()
    require(age in 0..130) { "age out of bounds [0,130] : $age" }
    return age
}

// check verifica un estado, error señala un caso imposible
fun process(state: String): String {
    check(state != "closed") { "operation impossible on a closed resource" }
    return when (state) {
        "open" -> "processing done"
        else -> error("unknown state: $state")
    }
}

Resultados:

> gradlew -q run -Pmain=basics22.Basics22Kt
[12] : age=12
[abc] : NumberFormatException - For input string: "abc"
[] : empty input
[99999999999] : NumberFormatException - For input string: "99999999999"
[-3] : IllegalArgumentException - age out of bounds [0,130] : -3
[150] : IllegalArgumentException - age out of bounds [0,130] : 150
name=dupont
IllegalArgumentException - the name is mandatory
age=45
IllegalArgumentException - age out of bounds [0,130] : 200
open : processing done
closed : IllegalStateException - operation impossible on a closed resource
broken : IllegalStateException - unknown state: broken

Comentarios:

  • línea 5: entradas simuladas, válidas o no;
  • línea 8: la función [readAge] (líneas 49–56) puede provocar varios tipos de excepciones;
  • línea 10: las entradas "abc", "" y "99999999999" provocan una [NumberFormatException];
  • líneas 12–15: en ausencia de un filtro, la entrada vacía se distingue dentro de la cláusula [catch];
  • línea 17: la excepción lanzada por la propia función [readAge] ;
  • Línea 26: [requireNotNull] lanza [IllegalArgumentException] si [name] es igual a [null]; su mensaje es el calculado por el bloque (línea 9 de los resultados). De lo contrario, devuelve [name] con el tipo [String]: la variable [valid] no es nulable;
  • línea 54: la función [readAge] lanza una excepción si la edad está fuera de los límites;
  • línea 62: la misma verificación, escrita con [require]. La condición usa el operador [in] y un rango;
  • línea 68: [check] verifica que el objeto esté en un estado que permita la operación;
  • línea 71: [error] lanza una [IllegalStateException]. Como su tipo es [Nothing], puede terminar una rama de una expresión [when] de tipo [String].

El orden de las cláusulas [catch] en las líneas 10 y 17 es importante: la clase [NumberFormatException] deriva de la clase [IllegalArgumentException] (una [NumberFormatException] es un caso particular de argumento incorrecto). Si se invierten las dos cláusulas, la cláusula [IllegalArgumentException] también intercepta las [NumberFormatException], y la cláusula [NumberFormatException] nunca vuelve a ejecutarse. El compilador de Java rechaza esta cláusula, que se volvió inalcanzable ([error: exception NumberFormatException has already been caught]); en cambio, el compilador de Kotlin 2.4 la acepta sin errores ni advertencias. La entrada vacía se mostraría entonces como [[] : NumberFormatException - For input string: ""], y el error pasaría inadvertido.

3.6.5. Kotlin no tiene excepciones comprobadas

Esta es una de las diferencias más notables entre Java y Kotlin. Las excepciones son objetos cuyas clases forman una jerarquía. Se trata de clases de Java: la clase [kotlin.Throwable] es simplemente otro nombre para [java.lang.Throwable], y lo mismo vale para las clases [Exception], [RuntimeException], [IllegalArgumentException]...:

Image

  • la clase raíz es [Throwable];
  • la clase [Error] y sus clases derivadas indican problemas graves de la máquina virtual ([OutOfMemoryError], [StackOverflowError]...), que un programa normalmente no intentaría interceptar;
  • la clase [RuntimeException] y sus derivadas ([NullPointerException], [ArithmeticException], [ArrayIndexOutOfBoundsException], [IllegalArgumentException], [NumberFormatException], [IllegalStateException]...) indican, por lo general, errores de programación o datos incorrectos;
  • las demás clases derivadas de [Exception] ([IOException], [InterruptedException], [ParseException], [SQLException]...) informan de incidentes causados por el entorno del programa (archivo inexistente, caída de la red, base de datos fuera de servicio) que un programa bien escrito debe prever.

En Java, las excepciones de esta última categoría se denominan «excepciones comprobadas» (checked exceptions): el compilador de Java verifica que un método capaz de lanzar una de ellas, ya sea directamente o al llamar a otro método, la capture mediante una cláusula [catch] o la declare en su firma mediante la palabra clave [throws]:

String readFile(String name) throws IOException { ... }

La responsabilidad se transfiere entonces a los métodos que realizan la llamada, y así sucesivamente. Las excepciones derivadas de [RuntimeException] y de [Error] se denominan «no comprobadas» (unchecked): pueden capturarse, pero el compilador no lo exige.

Kotlin no tiene excepciones comprobadas. Como en C#, todas las excepciones son no comprobadas: el compilador nunca exige capturar ni declarar una excepción, y la palabra clave [throws] no existe. Una [IOException] lanzada por un método de Java es, para Kotlin, una excepción más. Esta decisión de los diseñadores del lenguaje se basa en la experiencia adquirida con Java:

  • en los programas grandes, la obligación de declarar las excepciones se propaga de método en método, y las firmas de los métodos se sobrecargan de cláusulas [throws] que aportan poca información;
  • sin saber qué hacer con una excepción comprobada, muchos programadores la capturan con un bloque [catch] vacío solo para silenciar al compilador: el error desaparece en silencio, que es el peor resultado posible;
  • Las excepciones comprobadas no se llevan bien con las lambdas (capítulo 7): una lambda pasada a una función de biblioteca no puede lanzar una excepción comprobada sin algunos rodeos;
  • Por último, muchas bibliotecas recientes del ecosistema Java (Spring, Hibernate, que usaremos más adelante) ya utilizan únicamente excepciones no comprobadas. En el curso de Java, a menudo encapsulábamos una excepción comprobada en una no comprobada: en Kotlin, esto es innecesario.

La contrapartida es que el compilador ya no nos recuerda que una función puede fallar: corresponde al programador saber qué excepciones puede lanzar una función (la documentación lo indica) y capturarlas donde puedan manejarse.

Cuando una función de Kotlin debe ser llamada desde código Java, la anotación [@Throws(IOException::class)] genera en el bytecode la cláusula [throws IOException] que espera el compilador de Java. Sin ella, un programa Java que llame a la función y capture la excepción [IOException] es rechazado por el compilador de Java, que supone que la excepción no puede ocurrir ([error: exception IOException is never thrown in body of corresponding try statement]). La anotación no tiene ningún efecto sobre los llamadores de Kotlin.

El programa [Basics23.kt] cubre los diversos casos del programa Java correspondiente:

// no hay excepciones verificadas en Kotlin
package basics23

import java.io.IOException
import java.io.UncheckedIOException
import java.nio.file.NoSuchFileException
import kotlin.io.path.Path
import kotlin.io.path.readText

fun main() {
    // 1 - readFile puede lanzar una IOException: la capturamos porque queremos hacerlo
    try {
        val content = readFile("missing.txt")
        println(content)
    } catch (e: IOException) {
        println("readFile : ${e.javaClass.name} - ${e.message}")
    }
    // 2 - Thread.sleep puede lanzar una InterruptedException: no se requiere try
    pause(100)
    println("wait of 100 ms finished")
    // 3 - una ArithmeticException, como cualquier excepción, puede capturarse
    try {
        println("divide(1, 0) = ${divide(1, 0)}")
    } catch (e: ArithmeticException) {
        println("divide : ${e.javaClass.name} - ${e.message}")
    }
    // 4 - una excepción envuelta en otra, que agrega información
    try {
        println(readConfiguration("absent.properties"))
    } catch (e: UncheckedIOException) {
        println("${e.message} ; cause : ${e.cause?.javaClass?.simpleName}")
    }
    // 5 - el lugar de algunas excepciones en la jerarquía de clases
    println(ancestors(NoSuchFileException("x")))
    println(ancestors(NumberFormatException()))
    println(ancestors(OutOfMemoryError()))
}

// readText lanza una IOException: nada que declarar para Kotlin,
// @Throws la declara para los llamadores escritos en Java
@Throws(IOException::class)
fun readFile(name: String): String = Path(name).readText()

// Thread.sleep lanza una InterruptedException: nada que declarar
fun pause(milliseconds: Long) {
    Thread.sleep(milliseconds)
}

// una división entera puede lanzar una ArithmeticException
fun divide(a: Int, b: Int): Int = a / b

// la IOException se captura y luego se vuelve a lanzar, envuelta en una excepción más explícita
fun readConfiguration(name: String): String {
    try {
        return Path(name).readText()
    } catch (e: IOException) {
        throw UncheckedIOException("unreadable configuration: $name", e)
    }
}

// la cadena de clases padre de la clase de un objeto
fun ancestors(o: Any): String {
    val chain = StringBuilder()
    var cls: Class<*>? = o.javaClass
    while (cls != null) {
        if (chain.isNotEmpty()) {
            chain.append(" -> ")
        }
        chain.append(cls.simpleName)
        cls = cls.superclass
    }
    return chain.toString()
}

Resultados:

1
2
3
4
5
6
7
8
> gradlew -q run -Pmain=basics23.Basics23Kt
readFile : java.nio.file.NoSuchFileException - missing.txt
wait of 100 ms finished
divide : java.lang.ArithmeticException - / by zero
unreadable configuration: absent.properties ; cause : NoSuchFileException
NoSuchFileException -> FileSystemException -> IOException -> Exception -> Throwable -> Object
NumberFormatException -> IllegalArgumentException -> RuntimeException -> Exception -> Throwable -> Object
OutOfMemoryError -> VirtualMachineError -> Error -> Throwable -> Object

Comentarios:

  • líneas 41–42: la función de extensión [readText()] del paquete [kotlin.io.path] (capítulo 5) lee todo el contenido de un archivo, especificado mediante una ruta [Path]; puede lanzar una [IOException]. La función [readFile] no la intercepta y no tiene nada que declarar para Kotlin. La anotación [@Throws] está allí para un posible llamador Java;
  • líneas 12–16: la función [main] intercepta [IOException] porque así lo decide, no porque el compilador lo exija. Como el archivo no existe, la excepción lanzada es una *[NoSuchFileException]*, una clase derivada de *[IOException]*, cuyo mensaje es el nombre del archivo;
  • líneas 45–46: [Thread.sleep] suspende el programa durante la duración especificada en milisegundos; puede lanzar una [InterruptedException], que trataremos en el capítulo 8. En Java, esta es una excepción comprobada; en Kotlin, la función [pause] no requiere ninguna declaración;
  • línea 19: la llamada a [pause] no está anidada dentro de un [try / catch]. El programa Java correspondiente estaba obligado a hacerlo;
  • línea 50: una división entera puede lanzar una [ArithmeticException];
  • líneas 22–25: el llamador captura la excepción porque así lo decide;
  • líneas 53–57: en Java, encapsular una *[IOException] dentro de una *[UncheckedIOException] permitía omitirla de la declaración. En Kotlin, esta razón ya no se aplica, pero la técnica sigue siendo útil por otro motivo: la nueva excepción lleva un mensaje más explícito para el llamador («configuración ilegible»), y la excepción original se le pasa como la causa;
  • línea 31: la propiedad [cause] (el método Java [getCause()]) devuelve la excepción original. Es de tipo [Throwable?]: de ahí el operador [?.];
  • Líneas 62–72: la función [ancestors] recorre la cadena de clases padre de un objeto (propiedad [superclass], el método Java [getSuperclass()]) hasta la clase [Object], la raíz de todas las clases de Java. La variable [cls] es de tipo [Class<*>?] (una clase de cualquier tipo, o [null]), porque [superclass] devuelve [null] para la clase [Object];
  • Líneas 34–36: los resultados (las tres últimas líneas) reflejan la jerarquía descrita anteriormente. En Kotlin, la raíz de todas las clases es [Any], que corresponde a la clase Java [Object].

Si se elimina la anotación [@Throws] e incluso el [try / catch] de la función [main], el compilador de Kotlin sigue aceptando el programa. La excepción no capturada terminaría entonces el programa, que mostraría la excepción y la pila de llamadas y saldría con un código de retorno 1. Esto es aceptable para un pequeño programa de prueba, pero no para una aplicación real. En este curso, capturamos una excepción donde sabemos cómo manejarla.

3.6.6. Liberación de recursos: la función use

Un recurso (un archivo abierto, una conexión de red, una conexión a una base de datos) debe cerrarse después de usarse, incluso si ocurre un error durante su uso. Puede cerrarse dentro de una cláusula [finally], lo que requiere varias líneas de código que pueden ser delicadas de escribir. Java 7 introdujo con este fin el **try con recursos ([try (Type resource = ...) { ... }]*). Kotlin no tiene esta sintaxis; en su lugar, utiliza una función sencilla de su biblioteca estándar, la función *[use] :

1
2
3
resource.use { r ->
    use of the resource r
}

La función [use] se aplica a cualquier recurso cuyo tipo implemente la interfaz Java [AutoCloseable] (o [Closeable], que deriva de ella), una interfaz que contiene únicamente el método [close()]; este es el caso de todas las clases de archivos, de red y de bases de datos de Java. Ejecuta el bloque que se le pasa (una lambda, capítulo 7), cuyo parámetro [r] designa el recurso, y luego cierra el recurso (llamando a su método [close()]), ya sea que el bloque termine normalmente o con una excepción. Devuelve el valor del bloque. Si se omite el nombre del parámetro, el recurso se designa en el bloque como [it].

[use] es una función de extensión: una función escrita en Kotlin, fuera de la interfaz [AutoCloseable], pero que se llama como si fuera un método de esa interfaz. Aprenderemos a escribir este tipo de funciones en el capítulo 4. Varios recursos se manejan mediante bloques [use] anidados: el más interno se cierra primero. Un [use] puede colocarse dentro de un [try] junto con las cláusulas [catch] y [finally] , que se ejecutan después de cerrar los recursos.

Mencionamos antes que Kotlin no tiene la característica multi-catch de Java ([catch (NumberFormatException | ArithmeticException e)]). Para manejar varios tipos de excepciones de la misma manera, se captura un tipo común y luego se clasifican las excepciones mediante un [when].

El programa [Basics24.kt] es el siguiente:

// la función use reemplaza el try-with-resources de Java
package basics24

import java.io.StringReader

fun main() {
    // 1 - un recurso se cierra automáticamente al salir del bloque use
    openResource("R1").use { r ->
        println("using ${r.name}")
    }
    // 2 - varios recursos: llamadas use anidadas. Se cierran en el orden inverso
    // al de su apertura, incluso si ocurre una excepción, y antes de las cláusulas catch y finally
    try {
        openResource("R2").use { r2 ->
            openResource("R3").use { r3 ->
                println("using ${r2.name} and ${r3.name}")
                throw IllegalStateException("incident during use")
            }
        }
    } catch (e: IllegalStateException) {
        println("catch : ${e.message}")
    } finally {
        println("finally")
    }
    // 3 - un BufferedReader es un recurso
    StringReader("line 1\nline 2").buffered().use { reader ->
        while (true) {
            // readLine devuelve null al final del texto
            val line = reader.readLine() ?: break
            println("read: $line")
        }
    }
    // 4 - use devuelve el valor de su bloque
    val nbLines = StringReader("a\nb\nc").buffered().use { reader -> reader.readLines().size }
    println("number of lines: $nbLines")
    // 5 - el mismo manejo para varios tipos de excepción
    val operations = arrayOf(arrayOf("10", "2"), arrayOf("10", "zero"), arrayOf("10", "0"))
    for (operation in operations) {
        try {
            val a = operation[0].toInt()
            val b = operation[1].toInt()
            println("$a / $b = ${a / b}")
        } catch (e: RuntimeException) {
            when (e) {
                is NumberFormatException, is ArithmeticException ->
                    println("${operation.contentToString()} : ${e.javaClass.simpleName} - ${e.message}")
                // las demás excepciones se vuelven a lanzar
                else -> throw e
            }
        }
    }
}

// un recurso: un objeto que implementa la interfaz AutoCloseable (capítulo 4)
data class Resource(val name: String) : AutoCloseable {
    override fun close() {
        println("closing $name")
    }
}

fun openResource(name: String): Resource {
    println("opening $name")
    return Resource(name)
}

Resultados:

> gradlew -q run -Pmain=basics24.Basics24Kt
opening R1
using R1
closing R1
opening R2
opening R3
using R2 and R3
closing R3
closing R2
catch : incident during use
finally
read: line 1
read: line 2
number of lines: 3
10 / 2 = 5
[10, zero] : NumberFormatException - For input string: "zero"
[10, 0] : ArithmeticException - / by zero

Comentarios:

  • Líneas 55–57: un recurso de demostración. Es una data class (capítulo 4), una clase muy simple en la que cada objeto tiene un nombre; implementa la interfaz [AutoCloseable] redefiniendo ([override]) el método [close()], que muestra un mensaje;
  • líneas 61–63: la función [openResource] muestra un mensaje y crea un recurso;
  • líneas 8–9: el recurso [r] se cierra automáticamente al final del bloque (línea 4 de los resultados);
  • Líneas 14–17: dos recursos, con dos [use] anidados. Se lanza una excepción mientras se los utiliza (línea 17). Los resultados (líneas 5–11) muestran que R3 se cierra antes que R2, y que ambos se cierran antes de que se ejecuten las cláusulas [catch] y [finally] ;
  • línea 26: un [BufferedReader] que aquí lee una cadena como si fuera un archivo. La función de extensión [buffered()] crea un [BufferedReader] a partir del [StringReader], sin escribir [BufferedReader(StringReader(...))]. Leeremos archivos reales en el capítulo 5;
  • línea 29: [readLine()] devuelve la línea siguiente, o [null] al final del texto. En Kotlin, una asignación no es una expresión: no se puede escribir [while ((line = reader.readLine()) != null)], como en Java. El operador [?:] seguido de [break] (una expresión de tipo [Nothing], al igual que [throw]) sale del bucle cuando [readLine()] se evalúa como [null]. La variable [line] es entonces de tipo [String], que no es nulable. En el capítulo 5 veremos funciones que leen todas las líneas sin un bucle ([readLines], [forEachLine], [useLines]);
  • línea 34: [use] devuelve el valor de su bloque (en este caso, el número de líneas leídas por [readLines()]) después de cerrar el lector;
  • líneas 43–48: reemplazo del bloque multi-catch: se intercepta la clase padre común [RuntimeException] y luego un [when] aplica el mismo tratamiento a los dos tipos esperados (una cláusula [when] puede enumerar varias pruebas [is], separadas por comas). Las demás excepciones se vuelven a lanzar; los errores inesperados no se suprimen;
  • línea 46: [operation.contentToString()] devuelve el contenido del arreglo con la forma «[10, zero]», de modo similar a [Arrays.toString] en Java. La propiedad [e.javaClass.simpleName] proporciona el nombre de la clase de la excepción (líneas 16 y 17 de los resultados).

3.7. Aplicación de ejemplo - V1

Queremos escribir un programa que calcule el impuesto de un contribuyente. Consideraremos el caso simplificado de un contribuyente que solo tiene un salario que declarar. Las cifras provienen de la tabla de impuestos de 2004 para los ingresos de 2003 y se utilizan tal cual: es un ejercicio de programación, no un cálculo de impuestos vigentes. Esta aplicación será nuestro hilo conductor: volveremos a ella en los capítulos siguientes, incorporando clases, archivos, una base de datos, corrutinas y, finalmente, funcionalidades de red.

  • Se calcula el número de partes del empleado: partes = nbChildren/2 + 1 si el empleado es soltero, nbChildren/2 + 2 si es casado, donde nbChildren es el número de hijos;
  • si tiene al menos tres hijos, recibe media parte adicional;
  • su ingreso imponible R se calcula como R = 0.72 * S, donde S es su salario anual;
  • su cociente familiar se calcula como QF = R / partes;
  • su impuesto I se calcula con la tabla siguiente:
límite
coeffR
coeffN
4962
0
0
8382
0.068
291.09
14,753
0.191
1,322.92
23,888
0.283
2,668.39
38,868
0.374
4,846.98
47,932
0.426
6,883.66
0
0.481
9,505.54

Cada fila tiene 3 campos. Para calcular el impuesto I, se busca la primera fila en la que QF es menor o igual que el límite. Por ejemplo, si QF = 5,000, la fila encontrada será:

8382    0.068    291.09

El impuesto I es entonces igual a 0.068 * R - 291.09 * partes, redondeado al euro más cercano. Si QF es tal que la condición QF <= límite nunca se cumple, se utilizan los coeficientes de la última fila: I = 0.481 * R - 9505.54 * partes. Por lo tanto, el límite 0 de la última fila nunca se utiliza.

Los cálculos implican montos y coeficientes decimales: los realizamos con la clase Java [BigDecimal], que Kotlin utiliza directamente (e incluso de forma más cómoda que Java): la biblioteca estándar de Kotlin define los operadores [+], [-], [*], y los operadores de comparación [<], [>]... se aplican a cualquier objeto comparable. El programa Kotlin correspondiente [Tax1.kt] es el siguiente:

// cálculo del impuesto - versión 1
// escala de impuestos de 2004 (ingresos de 2003): es un ejercicio, no la escala de impuestos vigente
package tax1

import java.math.BigDecimal
import java.math.MathContext

fun main() {
    // arreglos de datos necesarios para el cálculo del impuesto
    val limits = decimals("4962", "8382", "14753", "23888", "38868", "47932", "0")
    val coeffR = decimals("0", "0.068", "0.191", "0.283", "0.374", "0.426", "0.481")
    val coeffN = decimals("0", "291.09", "1322.92", "2668.39", "4846.98", "6883.66", "9505.54")

    // estado civil
    val married = readMaritalStatus()
    // número de hijos
    val nbChildren = readPositiveInteger("Number of children: ")
    // salario anual
    val salary = readPositiveInteger("Annual salary: ")

    // número de partes
    var shares = nbChildren.toBigDecimal().divide(BigDecimal.TWO) + (if (married) 2 else 1).toBigDecimal()
    if (nbChildren >= 3) {
        shares += BigDecimal("0.5")
    }

    // ingreso imponible
    val income = BigDecimal("0.72") * salary.toBigDecimal()

    // cociente familiar (la división puede no ser exacta: se fija una precisión)
    val quotient = income.divide(shares, MathContext.DECIMAL128)

    // búsqueda del tramo impositivo: el primero tal que quotient <= limit,
    // el último si ninguno corresponde
    var i = 0
    while (i < limits.size - 1 && quotient > limits[i]) {
        i++
    }

    // el impuesto (truncado al euro)
    val tax = (coeffR[i] * income - coeffN[i] * shares).toInt()

    // visualización del resultado
    println("Tax to pay: $tax euros")
}

// muestra un mensaje, lee una línea y la devuelve sin espacios iniciales ni finales
// (cadena vacía si el flujo de entrada se agotó)
fun read(prompt: String): String {
    print(prompt)
    return (readlnOrNull() ?: "").trim()
}

// pregunta el estado civil hasta obtener una respuesta correcta
fun readMaritalStatus(): Boolean {
    while (true) {
        when (read("Are you married (Y/N)? ").lowercase()) {
            "y" -> return true
            "n" -> return false
            else -> System.err.println("Incorrect answer. Try again")
        }
    }
}

// pregunta un entero positivo o cero hasta obtener una respuesta correcta
fun readPositiveInteger(prompt: String): Int {
    while (true) {
        // toIntOrNull devuelve null si la entrada no es un entero: no hay excepción que manejar
        val number = read(prompt).toIntOrNull()
        if (number != null && number >= 0) {
            return number
        }
        System.err.println("Incorrect answer. Try again")
    }
}

// convierte cadenas en números BigDecimal exactos
fun decimals(vararg values: String): Array<BigDecimal> =
    Array(values.size) { i -> BigDecimal(values[i]) }

Comentarios:

  • Líneas 10–12: los tres arreglos de [BigDecimal] se construyen mediante la función [decimals] (líneas 78–79) a partir de cadenas de caracteres: por lo tanto, cada valor, como 0.068, es exacto. Con [Double], 0.068 sería solo una aproximación binaria. La función [decimals] acepta cualquier cantidad de parámetros ([vararg values: String]), que recibe en un arreglo; esta notación se explica en la sección «Paso de parámetros a una función». El arreglo resultante se construye mediante [Array(size) { i -> value }], que calcula cada elemento a partir de su índice;
  • línea 15: la entrada del estado civil la maneja la función [readMaritalStatus] (líneas 55–60). El programa Java realizaba todas las entradas en su método [main], con variables declaradas sin valores iniciales; en Kotlin, cada entrada es una función que devuelve el valor ingresado, y las variables [married], [nbChildren] y [salary] pueden ser [val];
  • línea 49: la función [read] muestra el mensaje con [print] (sin salto de línea) y lee la respuesta; si el flujo de entrada está cerrado, el valor [null] devuelto por [readlnOrNull] se reemplaza por una cadena vacía. La función [trim()] elimina los espacios iniciales y finales de la cadena leída;
  • líneas 56–60: un bucle [while (true)] que sale mediante [return] cuando la respuesta es correcta. El [when] opera sobre la respuesta convertida a minúsculas por [lowercase()]: esto permite aceptar tanto Y como y. En Kotlin, las cadenas se comparan con el operador [==], que compara su contenido (es lo que hace [when]); el método Java [equals] no es necesario;
  • línea 60: los mensajes de error se escriben en el flujo [System.err];
  • Líneas 66–73: entrada de un entero positivo o cero, utilizada para el número de hijos y para el salario: el programa Java repetía dos veces el mismo bucle. [toIntOrNull()] devuelve [null] si la entrada no es un entero: no hay ni un [try] ni una excepción que manejar. En la línea 70, después de la prueba [number != null], el compilador sabe que [number] no es [null]: acepta la comparación [number >= 0] y la instrucción [return number] de una función que devuelve un [Int] (conversión de tipo inteligente);
  • línea 22: el número de partes se calcula como [BigDecimal]. No se puede simplemente escribir [nbChildren / 2]: si nbChildren es 3, se obtendría 3/2, una división entera cuyo resultado sería 1 en lugar de 1.5. La función de extensión [toBigDecimal()] convierte el entero, [divide(BigDecimal.TWO)] lo divide exactamente entre dos, y el operador [+] suma 2 o 1, según lo determine una expresión [if]. Nota: el operador [/] de Kotlin aplicado a [BigDecimal] conserva el número de decimales del dividendo y redondea el resultado: [3.toBigDecimal() / 2.toBigDecimal()] es 2, no 1.5. Para una división con [BigDecimal], siempre se utiliza el método [divide];
  • línea 24: un [BigDecimal] es inmutable: el operador [+=] no modifica el objeto; crea un nuevo objeto [shares + BigDecimal("0.5")] y lo asigna a la variable, de ahí la declaración [var] de [shares]. En Java, habría que haber escrito [shares = shares.add(...)], y olvidar la asignación era un error clásico;
  • línea 28: el ingreso imponible, calculado con el operador [*];
  • línea 31: el cociente familiar. Dividir el ingreso entre 1.5 o 3.5 partes generalmente no da una representación decimal finita: se establece una precisión, aquí [MathContext.DECIMAL128] (34 dígitos significativos), que es más que suficiente;
  • líneas 35–37: determinación del tramo del impuesto. La búsqueda se detiene en el primer límite superior que es mayor o igual que el cociente familiar, y a más tardar en el último tramo, mediante la condición [i < limits.size - 1]. En Kotlin, el operador [>] se aplica a [BigDecimal]: [quotient > limits[i]] es traducido por el compilador a [quotient.compareTo(limits[i]) > 0], que es como lo habríamos escrito en Java. Sin embargo, no se comparan dos expresiones [BigDecimal] con [==], que llama a [equals] y tiene en cuenta el número de decimales: 2.0 y 2.00 no son «iguales» para [equals];
  • línea 41: el impuesto se trunca al euro más cercano mediante la función [toInt()], que descarta la parte decimal.

A continuación se muestran algunos ejemplos de la salida (las entradas, escritas con el teclado, se han incluido en la salida):

1
2
3
4
5
> gradlew -q run -Pmain=tax1.Tax1Kt
Are you married (Y/N)? y
Number of children: 2
Annual salary: 60000
Tax to pay: 4282 euros
> gradlew -q run -Pmain=tax1.Tax1Kt
Are you married (Y/N)? yes
Incorrect answer. Try again
Are you married (Y/N)? y
Number of children: three
Incorrect answer. Try again
Number of children: 3
Annual salary: 60000 euros
Incorrect answer. Try again
Annual salary: 60000
Tax to pay: 2959 euros
1
2
3
4
5
> gradlew -q run -Pmain=tax1.Tax1Kt
Are you married (Y/N)? n
Number of children: 0
Annual salary: 60000
Tax to pay: 11519 euros

Para un salario anual de 60,000 euros, un contribuyente casado con 2 hijos paga 4,282 euros, con 3 hijos 2,959 euros, y una persona soltera sin hijos 11,519 euros: son los resultados de la versión Java. En la segunda ejecución, la entrada «60000 euros» es rechazada: [toIntOrNull] solo acepta cadenas que representan un entero exacto (los espacios iniciales y finales fueron eliminados por [trim()]).

3.8. Argumentos del programa principal

La función principal [main] puede aceptar como parámetro un arreglo de cadenas [Array<String>]. Este arreglo contiene los argumentos de la línea de comandos con los que se inició la aplicación. Así, si iniciamos el programa P con el comando:

java -jar P.jar arg0 arg1 ... argn

y si la función [main] se declara de la siguiente manera:

fun main(args: Array<String>) {

tendremos args[0]="arg0", args[1]="arg1", y así sucesivamente. Cuando el programa no necesita sus argumentos, simplemente se escribe [fun main()], como hemos hecho hasta ahora. Con Gradle, los argumentos destinados al programa se pasan a la tarea [run] mediante la opción [--args], en forma de una sola cadena entre comillas; las opciones propias de Gradle (como [-q] o [-P]) se colocan junto a ella:

gradlew -q run -Pmain=package.ProgKt --args="a0 a1 a2"

En IntelliJ IDEA, los argumentos se ingresan en la configuración de ejecución del programa (en el campo «Program arguments»).

Este es un ejemplo, [Basics25.kt]:

1
2
3
4
5
6
7
8
9
// los argumentos de la línea de comandos
package basics25

fun main(args: Array<String>) {
    println("There are ${args.size} argument(s)")
    for (i in args.indices) {
        println("args[$i]=${args[i]}")
    }
}

Resultados:

1
2
3
4
5
6
> gradlew -q run -Pmain=basics25.Basics25Kt --args="a0 a1 a2 a3"
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

Un argumento que contiene espacios debe ir entre comillas; dentro de la cadena [--args], se utilizan comillas simples:

1
2
3
4
> gradlew -q run -Pmain=basics25.Basics25Kt --args="'jean dupont' 23"
There are 2 argument(s)
args[0]=jean dupont
args[1]=23

Sin argumentos, el arreglo [args] está vacío; nunca es igual a [null]:

> gradlew -q run -Pmain=basics25.Basics25Kt
There are 0 argument(s)

Comentarios:

  • línea 4: el punto de entrada del programa. El compilador genera una clase [Basics25Kt] que contiene un método [public static void main(String[] args)]: es exactamente el punto de entrada estándar de Java;
  • línea 5: el tamaño de un arreglo se especifica mediante su propiedad [size] (el campo [length] en Java);
  • líneas 6–7: recorrido de los índices del arreglo.

En Java, el método estándar [main] es un método estático de una clase. Kotlin no tiene métodos estáticos; sin embargo, si se desea que el punto de entrada sea una clase con un nombre específico (por ejemplo, para una herramienta que lo exige), se coloca la función [main] dentro de un object, declarado con la palabra clave [object] (capítulo 4), y se anota con [@JvmStatic]. Esto es lo que hace el programa [Basics26.kt]:

// los argumentos de la línea de comandos con una función main colocada en un object
package basics26

object Basics26 {
    @JvmStatic
    fun main(args: Array<String>) {
        println("There are ${args.size} argument(s)")
        for ((i, arg) in args.withIndex()) {
            println("args[$i]=$arg")
        }
    }
}

Resultados:

1
2
3
4
5
6
> gradlew -q run -Pmain=basics26.Basics26 --args="a0 a1 a2 a3"
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

Comentarios:

  • línea 4: un objeto [Basics26]. El compilador genera una clase [Basics26], con un único objeto;
  • Líneas 5–6: la anotación [@JvmStatic] indica al compilador que haga de [main] un método estático de la clase [Basics26], que es lo que espera la máquina virtual de Java. Por lo tanto, la clase que se debe ejecutar es [basics26.Basics26], no [basics26.Basics26Kt];
  • líneas 8–9: recorrido del arreglo mediante la función [withIndex()], que devuelve tanto el índice como el elemento.

Esta forma es poco frecuente en Kotlin: lo habitual es una función [main] de nivel superior, fuera de cualquier clase. Por último, observe que, como en Java, la función [main] no devuelve un valor: el código de salida del programa se establece con [exitProcess].

3.9. Enumeraciones

Una enumeración es un tipo de datos cuyo dominio de valores consiste en un conjunto de constantes con nombre. Consideremos un programa que debe manejar calificaciones de exámenes. Hay cinco calificaciones posibles: Aprobado, Bien, Notable, Muy bien y Excelente. Entonces podemos definir una enumeración para estas cinco constantes:

enum class Honours { PASS, FAIRLY_GOOD, GOOD, VERY_GOOD, EXCELLENT }

Kotlin escribe [enum class]*** donde Java escribe [enum]*: [enum] no es una palabra clave reservada, sino un modificador** de la declaración de una clase. Por convención, los nombres de las constantes se escriben en mayúsculas. Se puede declarar una variable que tome sus valores de la enumeración:

    val myHonours = Honours.PASS

Se puede comparar una variable con los distintos valores posibles de la enumeración mediante el operador ==:

1
2
3
    if (myHonours == Honours.PASS) {
        println("Could do better")
    }

Como en Java, y a diferencia de otros lenguajes donde una enumeración es simplemente un conjunto de enteros con nombre, una enumeración de Kotlin es una clase, compilada como una clase derivada de [java.lang.Enum], cuyos únicos objetos son las constantes declaradas. Cada constante es un objeto único, creado una vez y para siempre. Cada constante conoce su nombre (propiedad [name], o [toString()]) y su número ordinal en la declaración (propiedad [ordinal], que comienza en 0). Las constantes son comparables en este orden: se puede escribir [m1 < m2]. Toda enumeración tiene además:

  • [Honours.entries]: la lista (no modificable) de constantes de la enumeración [Honours], en el orden en que fueron declaradas. Es una mejor alternativa a la función [Honours.values()] (heredada de Java y todavía disponible), que crea un nuevo arreglo en cada llamada;
  • [Honours.valueOf(name)]: devuelve la constante llamada [name], y lanza una [IllegalArgumentException] si ninguna constante tiene ese nombre.

Una enumeración no puede convertirse en un entero, ni un entero en una enumeración: se utilizan [ordinal] y [entries].

El programa [Basics27.kt] ilustra lo que acaba de describirse:

// enumeraciones
package basics27

enum class Honours { PASS, FAIRLY_GOOD, GOOD, VERY_GOOD, EXCELLENT }

fun main() {
    // una variable que toma sus valores de la enumeración Honours
    val myHonours = Honours.PASS
    // visualización del valor de la variable
    println("honours=$myHonours")
    // prueba con un valor de la enumeración
    if (myHonours == Honours.PASS) {
        println("Could do better")
    }
    // lista de menciones: nombre y número ordinal
    for (m in Honours.entries) {
        println("${m.name} = ${m.ordinal}")
    }
    // número ordinal -> enumeración
    val m3 = Honours.entries[3]
    println("Honours.entries[3] = $m3")
    // cadena -> enumeración
    val m2 = Honours.valueOf("GOOD")
    println("m2=$m2, m2 after PASS : ${m2 > Honours.PASS}")
    try {
        Honours.valueOf("Good")
    } catch (e: IllegalArgumentException) {
        println("valueOf(\"Good\") : ${e.message}")
    }
    // sin excepción: null si la cadena no es el nombre de una constante
    val m4 = Honours.entries.find { it.name == "Good" }
    println("m4=$m4")
    // una enumeración en una expresión when: no se necesita else si se manejan todos los casos
    val assessment = when (myHonours) {
        Honours.PASS, Honours.FAIRLY_GOOD -> "correct"
        Honours.GOOD, Honours.VERY_GOOD -> "very correct"
        Honours.EXCELLENT -> "remarkable"
    }
    println("assessment : $assessment")
    println("type : ${Honours::class.java.name}")
    println("parent class : ${Honours::class.java.superclass.name}")
}

Resultados:

> gradlew -q run -Pmain=basics27.Basics27Kt
honours=PASS
Could do better
PASS = 0
FAIRLY_GOOD = 1
GOOD = 2
VERY_GOOD = 3
EXCELLENT = 4
Honours.entries[3] = VERY_GOOD
m2=GOOD, m2 after PASS : true
valueOf("Good") : No enum constant basics27.Honours.Good
m4=null
assessment : correct
type : basics27.Honours
parent class : java.lang.Enum

Comentarios:

  • línea 4: la declaración de la enumeración. Se coloca al principio del archivo, junto a las funciones; también puede declararse, como una clase (capítulo 4), en su propio archivo, [Honours.kt];
  • línea 8: una variable de tipo [Honours], con el tipo inferido a partir del valor asignado;
  • línea 10: una constante de enumeración se muestra por su nombre;
  • líneas 16–17: la lista de constantes, sus nombres y sus números de índice;
  • línea 20: la conversión de un número de índice en una constante: [entries] es una lista, que se indexa como un arreglo;
  • línea 23: conversión de una cadena en una constante de enumeración;
  • línea 24: las constantes se comparan según su orden de declaración: GOOD viene después de PASS. El operador [>] es traducido por el compilador a una llamada al método [compareTo], que en Java habría que escribir;
  • líneas 25–28: [valueOf] distingue entre mayúsculas y minúsculas: «Good» no es el nombre de una constante. El mensaje de la excepción proporciona el nombre completo de la enumeración, [basics27.Honours];
  • línea 31: para evitar la excepción, se puede buscar la constante en [entries] mediante la función [find], que devuelve el primer elemento que satisface la condición escrita entre llaves (una lambda, capítulo 7; donde [it] designa el elemento que se examina), o [null] si no hay ninguno;
  • líneas 34–37: las enumeraciones se prestan muy bien a las expresiones [when]. Como se procesan todas las constantes, la expresión es exhaustiva sin una cláusula [else]. Si más adelante se agrega una constante a la enumeración, el compilador rechazará la expresión [when], que se habrá vuelto incompleta, nombrando la constante omitida. Por ejemplo, sin la línea 37: [error: 'when' expression must be exhaustive. Add the 'EXCELLENT' branch or an 'else' branch.]. Esta es una buena razón para no incluir una cláusula [else] dentro de un [when] para una enumeración. A diferencia del [switch] de Java, las constantes llevan como prefijo el nombre de la enumeración; una instrucción [import basics27.Honours.*] permitiría escribir sus nombres solos;
  • línea 40: el nombre completo de la enumeración es [basics27.Honours]: se declara a nivel de archivo, en el paquete [basics27]. [Honours::class.java] es la clase Java de la enumeración;
  • línea 41: la clase padre de cualquier enumeración es [java.lang.Enum].

3.9.1. Enumeraciones avanzadas

Como una enumeración es una clase, puede tener propiedades, un constructor y métodos. Kotlin lo hace de forma particularmente concisa: las propiedades se declaran con [val] entre los paréntesis que siguen al nombre de la enumeración (el constructor primario, capítulo 4), y cada constante se crea llamando a este constructor con los valores escritos entre paréntesis después de su nombre. Es una característica muy utilizada que elimina la necesidad de gestionar arreglos de valores separados asociados a las constantes.

Para representar un conjunto de opciones, como los permisos de acceso a un archivo (lectura, escritura, ejecución), antes se combinaban potencias de 2 con el operador [or] (OR bit a bit). En su lugar, usamos una enumeración y la clase Java [EnumSet], un conjunto de constantes de una enumeración, que es igual de eficiente que una combinación bit a bit (internamente lo es), pero mucho más legible. La clase [EnumMap] es, de manera similar, un diccionario cuyas claves son las constantes de una enumeración. Kotlin las utiliza directamente.

El programa [Basics28.kt] es el siguiente:

// enumeraciones enriquecidas: propiedades, constructor, métodos; EnumSet y EnumMap
package basics28

import java.util.EnumMap
import java.util.EnumSet

// cada mención tiene una nota mínima y una etiqueta
enum class Honour(val minimumGrade: Int, val label: String) {
    PASS(10, "Pass"),
    FAIRLY_GOOD(12, "Fairly good"),
    GOOD(14, "Good"),
    VERY_GOOD(16, "Very good"),
    EXCELLENT(18, "Excellent");

    // un método: la siguiente mención (null para la última)
    fun next(): Honour? = entries.getOrNull(ordinal + 1)

    // una función de la propia enumeración: la mención que corresponde a una nota (null si grade < 10)
    companion object {
        fun forGrade(grade: Double): Honour? = entries.lastOrNull { grade >= it.minimumGrade }
    }
}

// permisos de acceso: un conjunto de valores se representará con un EnumSet
enum class Permission { READ, WRITE, EXECUTE }

fun main() {
    for (m in Honour.entries) {
        println("$m : \"${m.label}\" from ${m.minimumGrade}, next : ${m.next()}")
    }
    val grades = doubleArrayOf(8.5, 12.0, 15.5, 19.0)
    for (grade in grades) {
        val label = Honour.forGrade(grade)?.label ?: "no honours"
        println("grade $grade : $label")
    }

    // EnumSet: un conjunto de valores de una enumeración (reemplaza las combinaciones de bits)
    val permissions = EnumSet.of(Permission.READ, Permission.WRITE)
    println("permissions=$permissions, read : ${Permission.READ in permissions}, execute : ${Permission.EXECUTE in permissions}")
    permissions.add(Permission.EXECUTE)
    permissions.remove(Permission.WRITE)
    println("permissions=$permissions")
    println("all=${EnumSet.allOf(Permission::class.java)}, none=${EnumSet.noneOf(Permission::class.java)}" +
            ", complement of [READ]=${EnumSet.complementOf(EnumSet.of(Permission.READ))}")
    println("from FAIRLY_GOOD to VERY_GOOD : ${EnumSet.range(Honour.FAIRLY_GOOD, Honour.VERY_GOOD)}")

    // EnumMap: un diccionario cuyas claves son los valores de una enumeración (capítulo 5)
    val headcounts = EnumMap<Honour, Int>(Honour::class.java)
    headcounts[Honour.GOOD] = 7
    headcounts[Honour.PASS] = 12
    println("headcounts=$headcounts")
}

Resultados:

> gradlew -q run -Pmain=basics28.Basics28Kt
PASS : "Pass" from 10, next : FAIRLY_GOOD
FAIRLY_GOOD : "Fairly good" from 12, next : GOOD
GOOD : "Good" from 14, next : VERY_GOOD
VERY_GOOD : "Very good" from 16, next : EXCELLENT
EXCELLENT : "Excellent" from 18, next : null
grade 8.5 : no honours
grade 12.0 : Fairly good
grade 15.5 : Good
grade 19.0 : Excellent
permissions=[READ, WRITE], read : true, execute : false
permissions=[READ, EXECUTE]
all=[READ, WRITE, EXECUTE], none=[], complement of [READ]=[WRITE, EXECUTE]
from FAIRLY_GOOD to VERY_GOOD : [FAIRLY_GOOD, GOOD, VERY_GOOD]
headcounts={PASS=12, GOOD=7}

Comentarios:

  • Línea 8: la enumeración y su constructor primario. Las palabras clave [val] hacen de [minimumGrade] y [label] propiedades de solo lectura de cada constante. El programa Java habría tenido que declarar dos campos llamados [private final], escribir el constructor que los inicializa y luego escribir dos métodos, [getMinimumGrade] y [getLabel], para leerlos: Kotlin genera todo esto. El constructor de una enumeración es privado: no se pueden crear constantes adicionales;
  • líneas 9–13: las constantes de la enumeración, cada una con sus dos parámetros. El punto y coma después de la última constante es obligatorio cuando le siguen miembros: es uno de los poquísimos puntos y coma obligatorios en Kotlin;
  • línea 16: un método que se aplica a una constante ([m.next()]). Utiliza la propiedad [ordinal] de la constante y la lista [entries]; [getOrNull] devuelve el elemento del índice dado, o [null] si el índice está fuera de los límites: la última constante no tiene sucesora. El tipo de retorno [Honour?] lo indica;
  • líneas 19–20: una función que se llama sobre la propia enumeración ([Honour.forGrade(grade)]), similar a un método estático de Java. Kotlin no tiene métodos estáticos: se colocan en el objeto complementario (companion object) de la clase ([companion object]), presentado en el capítulo 4. Como las constantes se declaran en orden ascendente de calificación, la última cuya calificación mínima se cumple es la correcta: [lastOrNull] devuelve el último elemento de la lista que satisface la condición, o [null] si no hay ninguno. El resultado es de tipo [Honour?], o [null] si la calificación es inferior a 10: donde Java usaba un [Optional], Kotlin usa un tipo nulable;
  • línea 25: una enumeración simple para los derechos de acceso;
  • líneas 28–29: la lista de entradas con sus propiedades: se escribe [m.label], no [m.getLabel()];
  • línea 31: un arreglo de números reales [DoubleArray]. Las calificaciones se escriben como 12.0 y 19.0, no 12 y 19: Kotlin no convierte implícitamente un [Int] en un [Double];
  • línea 33: el operador [?.] lee la propiedad [label] solo si [Honour.forGrade(grade)] no es [null]; el operador [?:] devuelve un texto en caso contrario. Esto equivale a [map(Honour::getLabel).orElse("no honours")] de Java;
  • línea 38: un conjunto de dos derechos;
  • línea 39: el operador [in] verifica si una constante pertenece al conjunto, tal como se verificaría un bit. El compilador lo traduce a una llamada al método [contains];
  • líneas 40–41: se agregan y se quitan constantes del conjunto;
  • líneas 43–44: el conjunto de todas las constantes, el conjunto vacío y el complemento de un conjunto. [Permission::class.java] es la clase Java de la enumeración, que estos métodos de Java llaman ([Permission.class] en Java);
  • línea 45: las constantes comprendidas entre dos constantes, en el orden en que fueron declaradas;
  • líneas 48–50: un [EnumMap] asocia un conjunto de elementos con ciertas entradas. La notación [headcounts[key] = value] reemplaza la llamada [headcounts.put(key, value)]. Las claves de un [EnumMap] siempre se recorren en el orden en que se declaran las constantes: PASS aparece antes que GOOD, aunque se haya agregado después. Los diccionarios se tratan en el capítulo 5.

3.10. Paso de parámetros a una función

En Kotlin, una función puede declararse en el nivel superior de un archivo, fuera de cualquier clase, como nuestras funciones [main]: se denominan funciones de nivel superior. Una función declarada dentro de una clase es un método (capítulo 4). Aquí nos centraremos en cómo se pasan los parámetros a una función. Consideremos la función siguiente:

1
2
3
fun changeInt(a: Int) {
    println("Formal parameter a=$a")
}

En la definición de la función, en la línea 1, [a] se denomina parámetro formal. Se incluye únicamente para los fines de la definición de la función [changeInt]. Podría haberse llamado perfectamente [b]. Su tipo es obligatorio: la inferencia de tipos no se aplica a los parámetros. Consideremos ahora un uso de esta función:

1
2
3
    val age = 20
    changeInt(age)
    println("Actual parameter age=$age")

Aquí, en la instrucción de la línea 2, [age] es el parámetro actual (también llamado argumento) que pasará su valor al parámetro formal [a]. Nos interesa cómo un parámetro formal obtiene el valor de un parámetro actual.

3.10.1. Paso por valor y parámetros inmutables

Como Java, Kotlin tiene un único modo de paso de parámetros: el paso por valor. El valor del parámetro actual se copia en el parámetro formal correspondiente. Son dos entidades distintas.

Kotlin va un paso más allá que Java: un parámetro formal es siempre un [val]. No se le puede asignar un nuevo valor dentro de la función; es como si, en Java, todos los parámetros se declararan como [final]. Por lo tanto, la pregunta «¿puede la función modificar el parámetro actual modificando su parámetro formal?» ni siquiera se plantea. Si la función necesita una variable que modifica, declara una variable local inicializada con el valor del parámetro.

Cuando el parámetro es un arreglo o un objeto, el valor que se pasa es la referencia al objeto: el parámetro formal y el parámetro actual hacen referencia entonces al mismo objeto. Por lo tanto, la función puede modificar este objeto, si es mutable, y quien la llamó verá el cambio; sin embargo, no puede hacer que la variable del llamador haga referencia a un objeto diferente.

Kotlin no admite el paso por referencia, en el que el parámetro formal y el parámetro actual serían una misma variable (como los parámetros [ref] y [out] de C#): una función no puede modificar una variable local de su llamador, ni «devolverle» resultados a través de sus parámetros. En su lugar, se utiliza:

  • el valor de retorno de la función, que el llamador asigna a su variable;
  • una data class o una tupla ([Pair], [Triple]) cuando la función debe devolver varios valores;
  • un arreglo o un objeto mutable pasado como parámetro, en el que la función coloca sus resultados.

El programa [Basics29.kt] ilustra estos diferentes casos:

// paso de parámetros: siempre por valor, y los parámetros son val
package basics29

import java.math.BigDecimal

fun main() {
    // 1 - paso por valor: el parámetro real no se modifica
    val age = 20
    changeInt(age)
    println("Actual parameter age=$age")

    // 2 - para modificar una variable del llamador: la función devuelve el nuevo valor
    var age2 = 20
    age2 = changeInt2(age2)
    println("Actual parameter age2=$age2")

    // 3 - para devolver varios valores: una data class
    val c1 = convert("123")
    val c2 = convert("12x")
    println("c1=$c1, c2=$c2")
    if (c1.succeeded) {
        println("value of c1 : ${c1.value}")
    }

    // 4 - un intercambio de valores: los valores se almacenan en un arreglo
    val xy = intArrayOf(1, 2)
    swap(xy)
    println("after swap : x=${xy[0]}, y=${xy[1]}")
    // intercambio de dos variables locales, sin función ni variable temporal
    var x = 1
    var y = 2
    x = y.also { y = x }
    println("after swap : x=$x, y=$y")

    // 5 - un arreglo pasado por valor: se copia su referencia
    val array = intArrayOf(1, 2, 3)
    modifyArray(array)
    println("array=${array.contentToString()}")

    // 6 - un objeto modificable (mutable): la función modifica el objeto referenciado
    val message = StringBuilder("Hello")
    complete(message)
    println("message=$message")

    // 7 - un parámetro no puede recibir un nuevo valor en la función
    val price = BigDecimal("100")
    println("InclTax($price)=${inclTax(price)}")
}

// el resultado de una conversión: éxito y valor obtenido
data class Conversion(val succeeded: Boolean, val value: Int)

fun changeInt(a: Int) {
    // a = 30 sería rechazado: un parámetro es un val. Trabajamos con una copia local
    var copy = a
    copy += 10
    println("Formal parameter a=$a, local copy=$copy")
}

fun changeInt2(a2: Int): Int {
    println("Formal parameter a2=$a2")
    return a2 + 10
}

fun convert(text: String): Conversion =
    try {
        Conversion(true, text.toInt())
    } catch (_: NumberFormatException) {
        Conversion(false, 0)
    }

fun swap(t: IntArray) {
    val temp = t[0]
    t[0] = t[1]
    t[1] = temp
}

fun modifyArray(t: IntArray) {
    // modificamos el arreglo referenciado: el llamador ve la modificación
    t[0] = 100
    // t = intArrayOf(7, 8, 9) sería rechazado: no se puede hacer que t apunte a otro arreglo
    println("in modifyArray : t=${t.contentToString()}")
}

fun complete(text: StringBuilder) {
    text.append(" everyone")
}

fun inclTax(amount: BigDecimal): BigDecimal {
    // amount = BigDecimal.ZERO sería rechazado: un parámetro es un val
    return amount * BigDecimal("1.2")
}

Resultados:

> gradlew -q run -Pmain=basics29.Basics29Kt
Formal parameter a=20, local copy=30
Actual parameter age=20
Formal parameter a2=20
Actual parameter age2=30
c1=Conversion(succeeded=true, value=123), c2=Conversion(succeeded=false, value=0)
value of c1 : 123
after swap : x=2, y=1
after swap : x=2, y=1
in modifyArray : t=[100, 2, 3]
array=[100, 2, 3]
message=Hello everyone
InclTax(100)=120.0

Comentarios:

  • Líneas 8–10: el valor 20 del parámetro actual [age] se copió en el parámetro formal [a] (línea 53). La función no puede modificar [a]: crea una copia local, [copy] (línea 55), que luego modifica. El parámetro actual permanece sin cambios;
  • líneas 13–15: la función [changeInt2] (líneas 60–62) devuelve un nuevo valor, que el llamador asigna a su propia variable [age2], declarada como [var] para este fin;
  • línea 51: una data class ([data class]) declara, en una sola línea, una clase cuyos objetos están formados por dos valores inmutables, [succeeded] y [value]. El compilador agrega, entre otros, un método llamado [toString()], que muestra sus componentes, así como los métodos [equals()] y [hashCode()]. Es el equivalente en Kotlin de los records de Java; las data classes se tratan en el capítulo 4. Sus componentes son propiedades: se escribe [c1.succeeded], no [c1.succeeded()] como con un record;
  • Líneas 18–22: la función [convert] (líneas 65–69) devuelve dos datos (si la conversión tuvo éxito y el valor obtenido) combinados en un solo objeto [Conversion]. Su cuerpo es una expresión [try], que se evalúa como uno u otro objeto [Conversion]. Observe que, en Kotlin, normalmente se escribiría una función de tipo [Int?] que devuelva [null] en caso de fallo: es exactamente lo que hace [toIntOrNull()];
  • líneas 26–28: intercambio de dos valores. Una función de tipo [swap(a: Int, b: Int)] no le serviría de nada al llamador; por lo tanto, los dos valores se almacenan en un arreglo, que la función [swap] (líneas 72–75) modifica;
  • líneas 30–32: para intercambiar dos variables locales, Kotlin ofrece un modismo: [x = y.also { y = x }]. La función [also] ejecuta el bloque, que asigna el valor de [x] a [y], y luego devuelve el valor de [y] anterior a la ejecución del bloque, que se asigna a [x]. Funciones como [also] se tratan en el capítulo 7;
  • líneas 36–38: la referencia al arreglo se pasa por valor. Por lo tanto, la función [modifyArray] opera sobre el mismo arreglo que el llamador: la modificación realizada por [t[0]] (línea 80) es visible para el llamador. Sin embargo, es imposible hacer que [t] apunte a un arreglo diferente: [t] es un [val];
  • Líneas 41–43: un objeto [StringBuilder] es una cadena mutable: la función [complete] (líneas 85–86) le agrega texto, y el llamador ve el resultado. Con un [String], esto habría sido imposible: los objetos [String] son inmutables;
  • líneas 46–47: la función [inclTax] (líneas 89–91) calcula un precio que incluye todos los impuestos. El producto de dos objetos [BigDecimal] tiene tantos decimales como la suma de los de sus dos factores: 100 × 1.2 = 120.0, que se muestra como 120.0.

Si el comentario de la línea 90 se reemplaza por la instrucción [amount = BigDecimal.ZERO], el compilador rechaza el programa:

1
2
3
error: 'val' cannot be reassigned.
    amount = BigDecimal.ZERO
    ^^^^^^

3.10.2. Valores predeterminados, argumentos con nombre, sobrecarga, número variable de parámetros

Java no tiene parámetros opcionales ni argumentos con nombre y debe simularlos mediante la sobrecarga de métodos: varias versiones del mismo método, en las que las versiones cortas llaman a la versión completa con valores predeterminados. Kotlin, como C#, tiene ambos:

  • un parámetro puede tener un valor predeterminado: [fun greet(name: String, greeting: String = "Hello")]. El llamador puede entonces omitir el parámetro actual correspondiente: [greet("Pierre")];
  • al llamar al método, un argumento puede tener nombre: [greet("Pierre", upperCase = true)]. Esto permite omitir un parámetro que tiene un valor predeterminado y pasar los siguientes, pasar los argumentos en cualquier orden y, sobre todo, hacer que la llamada sea legible: [upperCase = true] es más claro que un [true] aislado en una lista de argumentos.

Los valores predeterminados y los argumentos con nombre vuelven innecesarias la mayoría de las sobrecargas, y los «builders» de Java. La sobrecarga sí existe, sin embargo, en Kotlin: varias funciones pueden tener el mismo nombre si sus listas de parámetros difieren en el número o el tipo de los parámetros; el compilador selecciona la adecuada según los parámetros actuales. Esto se utiliza cuando el procesamiento difiere según el tipo de los parámetros. Para permitir que una función de Kotlin con parámetros predeterminados se llame desde Java con menos argumentos, la anotación [@JvmOverloads] indica al compilador que genere las sobrecargas correspondientes.

Por último, una función puede tener un número variable de parámetros: el parámetro formal va precedido de la palabra clave [vararg], [vararg numbers: Int]. El llamador puede pasar una lista de valores, que puede estar vacía, que el compilador organiza en un arreglo; dentro de la función, el parámetro es un arreglo ([IntArray] para [Int], [Array<String>] para [String]...). A diferencia de Java, no se puede pasar directamente un arreglo en lugar de la lista de valores: hay que «expandirlo» con el operador de propagación ([*]), [sum(*values)], que además permite mezclar arreglos y valores individuales.

El programa [Basics30.kt] es el siguiente:

// valores por defecto, argumentos con nombre, sobrecarga, número variable de parámetros
package basics30

fun main() {
    // parámetros con un valor por defecto: basta una sola función
    println(greet("Pierre"))
    println(greet("Pierre", "Good evening"))
    // un argumento con nombre: pasamos upperCase sin pasar greeting
    println(greet("Pierre", upperCase = true))
    // todos los argumentos con nombre, en cualquier orden
    println(greet(upperCase = true, greeting = "Hi", name = "Paul"))

    // sobrecarga: varias funciones con el mismo nombre, elegidas según el tipo del parámetro
    describe(12)
    describe(12.5)
    describe("twelve")

    // vararg: número variable de parámetros
    println("sum()=${sum()}")
    println("sum(1, 2, 3)=${sum(1, 2, 3)}")
    val values = intArrayOf(10, 20, 30)
    // el operador * expande los elementos del arreglo
    println("sum(*values)=${sum(*values)}")
    println("sum(1, *values, 100)=${sum(1, *values, 100)}")
    // funciones de Kotlin y del JDK con un número variable de parámetros
    println(listOf(1, 2, 3, 4))
    println("%s, %s and %s".format("one", "two", "three"))
    println(maxOf(3, 9, 4, 7))
    println(setOf("a", "b", "a", "c"))
}

// una función en la que dos de sus parámetros tienen un valor por defecto
fun greet(name: String, greeting: String = "Hello", upperCase: Boolean = false): String {
    val message = "$greeting $name"
    return if (upperCase) message.uppercase() else message
}

// tres funciones con el mismo nombre que se distinguen por el tipo de su parámetro
fun describe(n: Int) = println("$n is an integer")

fun describe(x: Double) = println("$x is a real")

fun describe(s: String) = println("\"$s\" is a string of ${s.length} characters")

fun sum(vararg numbers: Int): Int {
    // numbers es un arreglo de enteros (IntArray)
    var sum = 0
    for (number in numbers) {
        sum += number
    }
    return sum
}

Resultados:

> gradlew -q run -Pmain=basics30.Basics30Kt
Hello Pierre
Good evening Pierre
HELLO PIERRE
HI PAUL
12 is an integer
12.5 is a real
"twelve" is a string of 6 characters
sum()=0
sum(1, 2, 3)=6
sum(*values)=60
sum(1, *values, 100)=161
[1, 2, 3, 4]
one, two and three
9
[a, b, c]

Comentarios:

  • Líneas 33–35: una sola función, [greet], en la que dos parámetros tienen valores predeterminados. El programa Java requería tres métodos sobrecargados. El cuerpo de la función devuelve el valor de una expresión [if];
  • Línea 6: [greeting] y [upperCase] toman sus valores predeterminados, "Hello" y [false];
  • línea 7: [greeting] recibe «Good evening» y [upperCase] recibe su valor predeterminado;
  • línea 9: gracias al argumento con nombre, se pasa [upperCase] sin pasar [greeting], que conserva su valor predeterminado. En Java, también había que pasar el saludo;
  • línea 11: todos los argumentos tienen nombre, en un orden diferente al de la declaración;
  • líneas 39–43: tres funciones [describe] que difieren en el tipo de su parámetro. Son funciones con cuerpo de expresión: el cuerpo, reducido a una sola expresión, se escribe inmediatamente después del signo [=], sin llaves ni [return]. El tipo de retorno se infiere entonces de la expresión ([Unit] aquí; el tipo de [println]: la función no devuelve un valor útil);
  • líneas 14–16: el compilador selecciona la función según el tipo del parámetro actual. El carácter ["] se escribe como [\"] dentro de una cadena (línea 43);
  • líneas 45–51: [sum] acepta cualquier cantidad de enteros, recibidos en el arreglo [numbers] de tipo [IntArray];
  • líneas 19–24: [sum] se llama sin parámetros, con tres enteros, con los elementos de un arreglo expandidos por el operador [*], y luego con una combinación de las dos formas;
  • líneas 26–29: muchas funciones de Kotlin tienen un número variable de parámetros: [listOf], [setOf], [arrayOf], [format], [maxOf]... La función de extensión [format] se aplica a la cadena de formato, no a la clase [String] como el método estático [String.format] de Java. Kotlin no tiene métodos estáticos: [String.join(" - ", "a", "b", "c")] no existe en Kotlin (se escribiría [listOf("a", "b", "c").joinToString(" - ")], capítulo 5). El conjunto creado por [setOf] elimina el "a" duplicado.

3.11. Funciones locales y tuplas: las soluciones de Kotlin

3.11.1. Funciones locales, lambdas y clases locales

A diferencia de Java, Kotlin permite definir una función local, es decir, una función escrita dentro de otra función y utilizable solo dentro de ese ámbito. Esto es útil para dividir una función larga sin saturar todo el archivo con funciones visibles. Una función local tiene acceso a las variables locales de la función que la contiene y puede modificarlas.

Dentro de una función, también se tiene acceso a:

  • Las lambdas, que son pequeñas funciones anónimas que pueden almacenarse en una variable: [val cube = { x: Int -> x * x * x }]. La variable tiene entonces un tipo funcional, en este caso [(Int) -> Int], y la lambda se llama como una función: [cube(3)]. Las lambdas se tratan en el capítulo 7, «Tipos funcionales, lambdas y eventos». A diferencia de Java, una lambda de Kotlin puede modificar las variables locales [var] que la rodean;
  • las clases locales, declaradas dentro de la función y utilizables solo dentro de ella.

3.11.2. Pares, tripletas, desestructuración y clases de datos

Otros lenguajes tienen tuplas, que agrupan varios valores sin necesidad de declarar un tipo. Kotlin no tiene una sintaxis específica para ellas, pero su biblioteca estándar proporciona dos data classes genéricas, [Pair<A, B>] y [Triple<A, B, C>], cuyos componentes se llaman [first], [second], y [third]. Un par se crea con [Pair(1, "one")] o, de forma más legible, con la función infija [to]: [1 to "one"].

Los componentes de un par, de una tripleta y de cualquier data class pueden extraerse en una sola instrucción mediante una declaración de desestructuración: [val (number, name) = pair] declara dos variables, inicializadas con el primer y el segundo componente. Un componente innecesario se reemplaza por _: [val (_, age, _) = triple]. La desestructuración también se usa en un bucle, como [for] (como vimos con [withIndex()]), y en los parámetros de una lambda. Se basa en la posición de los componentes, no en sus nombres: [val (name, number) = pair] colocaría el número en [name].

Para dar nombre a los componentes de una tupla, se declara una data class: [data class Couple(val number: Int, val name: String)]. Equivale a un record de Java, pero es más flexible (una data class puede tener componentes como [var], desestructurarse, etc.). Las tuplas son cómodas para un uso local cuando la relación entre los dos valores es evidente; en cuanto una función pública devuelve varios valores, una data class, cuyos componentes tienen nombre, hace el código más legible.

El programa [Basics31.kt] es el siguiente:

// funciones locales, lambdas, clases locales; Pair, Triple, desestructuración, data classes
package basics31

fun main() {
    // una función local: declarada en main, solo puede usarse allí
    fun square(x: Int) = x * x
    println("square(7)=${square(7)}")
    // una lambda almacenada en una variable (capítulo 7)
    val cube = { x: Int -> x * x * x }
    println("cube(3)=${cube(3)}")

    // una función local o una lambda puede leer y modificar las variables locales que la rodean
    var counter = 0
    fun increment() {
        counter++
    }
    val increment2 = { counter += 10 }
    increment()
    increment()
    increment2()
    println("counter=$counter")

    // una clase local: declarada en la función, solo puede usarse allí
    class Accumulator {
        var total = 0
            private set

        fun add(value: Int) {
            total += value
        }
    }
    val acc = Accumulator()
    acc.add(5)
    acc.add(8)
    println("total=${acc.total}")

    // Pair y Triple: tuplas de dos y tres elementos
    val pair = Pair(1, "one")
    val pair2 = 2 to "two"
    println("pair=$pair, pair.first=${pair.first}, pair.second=${pair.second}, pair2=$pair2")
    val triple = Triple("Dupont", 45, true)
    println("triple=$triple, triple.third=${triple.third}")
    // declaración de desestructuración: una tupla dividida en varias variables
    val (number, name) = pair2
    println("number=$number, name=$name")
    val (_, age, _) = triple
    println("age=$age")
    // desestructuración en un bucle for
    for ((n, label) in listOf(1 to "one", 2 to "two", 3 to "three")) {
        print("$n:$label ")
    }
    println()

    // una data class: una tupla cuyos componentes tienen nombre
    data class Couple(val number: Int, val name: String)
    val t1 = Couple(1, "one")
    println("t1=$t1, t1.number=${t1.number}, t1.name=${t1.name}")
    // prueba de tipo y desestructuración
    val obj: Any = Couple(3, "three")
    if (obj is Couple) {
        val (num, label) = obj
        println("number=$num, name=$label")
    }

    // funciones que devuelven varios valores
    val (quotient, remainder) = divide(17, 5)
    println("17 = 5 * $quotient + $remainder")
    val d = divide(23, 4)
    println("d=$d, d.quotient=${d.quotient}")
    val (min, max) = minMax(intArrayOf(12, -4, 35, 7))
    println("min=$min, max=$max")

    // intercambio de dos variables con un par
    var a = 1
    var b = 2
    val (newA, newB) = b to a
    a = newA
    b = newB
    println("a=$a, b=$b")
}

// una data class en lugar de un registro
data class IntegerDivision(val quotient: Int, val remainder: Int)

fun divide(a: Int, b: Int) = IntegerDivision(a / b, a % b)

// un par, cuando el significado de los dos valores es evidente
fun minMax(values: IntArray): Pair<Int, Int> {
    var min = values[0]
    var max = values[0]
    for (v in values) {
        if (v < min) min = v
        if (v > max) max = v
    }
    return min to max
}

Resultados:

> gradlew -q run -Pmain=basics31.Basics31Kt
square(7)=49
cube(3)=27
counter=12
total=13
pair=(1, one), pair.first=1, pair.second=one, pair2=(2, two)
triple=(Dupont, 45, true), triple.third=true
number=2, name=two
age=45
1:one 2:two 3:three
t1=Couple(number=1, name=one), t1.number=1, t1.name=one
number=3, name=three
17 = 5 * 3 + 2
d=IntegerDivision(quotient=5, remainder=3), d.quotient=5
min=-4, max=35
a=2, b=1

Comentarios:

  • línea 6: una función local con cuerpo de expresión, declarada en la función [main] y llamada en la línea 7;
  • línea 9: una lambda. [{ x: Int -> x * x * x }] se lee «la función que asocia x * x * x a un entero x». El compilador infiere el tipo de las variables [cube] y [(Int) -> Int] ;
  • línea 10: la lambda se llama como una función. En Java, había que conocer el método de la interfaz funcional ([applyAsInt]);
  • líneas 13–21: la función local [increment] y la lambda [increment2] modifican ambas la variable local [counter] de la función [main]: 1 + 1 + 10 = 12. En Java, una lambda no podía modificar una variable local, por lo que era necesario usar un arreglo de un solo elemento;
  • líneas 24–29: una clase local *[Accumulator]*, con una propiedad *[total] y un método *[add]. [private set] hace que la propiedad solo pueda escribirse dentro de la clase: puede leerse desde [main] (línea 35), pero no modificarse. Las clases se tratan en el capítulo 4;
  • líneas 32–34: se crea un objeto de tipo [Accumulator] llamando a su constructor (sin el operador [new]) y luego se llama a su método;
  • líneas 38–40: dos pares, creados mediante el constructor [Pair] y la función [to]. El método [toString()] de un par lo muestra entre paréntesis;
  • líneas 41–42: una tripleta de tres tipos diferentes;
  • línea 44: el par [pair2] se divide en dos variables, [number] y [name];
  • línea 46: solo se conserva el segundo componente de la tripleta;
  • líneas 49–50: desempaquetado de cada par de una lista dentro del bucle [for];
  • línea 55: una data class local;
  • línea 57: el método [toString()] de una data class muestra el nombre de la clase y sus componentes; las propiedades [number] y [name] devuelven los componentes;
  • líneas 59–62: después de la verificación [obj is Couple], [obj] se trata como un [Couple] (conversión de tipo inteligente) y puede desestructurarse. Kotlin no tiene un equivalente de los record patterns de Java 21 ([obj instanceof Couple(int number, String name)]), pero la verificación de tipo seguida de una asignación por desestructuración produce el mismo resultado;
  • líneas 66–71: las funciones [divide] y [minMax] (líneas 85–95) devuelven cada una dos valores: la primera en una data class [IntegerDivision] (línea 83), y la segunda como un par. El llamador puede desestructurar el resultado (líneas 66 y 70) o almacenarlo en una variable y usar los nombres de los componentes (líneas 68–69);
  • líneas 74–78: intercambio de dos variables mediante un par. Kotlin no permite asignar a variables existentes en una sola instrucción mediante desestructuración ([(a, b) = b to a] es rechazado): se desestructura en dos variables nuevas, que luego se asignan. El modismo [a = b.also { b = a }] del programa [Basics29.kt] es más corto;
  • líneas 92–93: una instrucción [if] cuya única acción se escribe en la misma línea, sin llaves.

En un programa más grande, definimos clases, que agrupan datos y las funciones que los manipulan: este es el tema del capítulo siguiente.