Kotlin Desde Cero: Variables, Tipos Básicos y Arreglos

() translation by (you can also view the original English article)

Kotlin es un lenguaje de programación moderno que compila a código byte Java. Es gratuito de y de código abierto, y promete hacer el codificar para Android incluso más divertido.

Kotlin es 100% interoperable con Java. En otras palabras, puede ser usado junto con Java en el mismo proyecto. Así que puedes refactorizar partes de tu código Java a Kotlin y no se romperá. En adición a eso, es conciso, expresivo, y tiene gran estampación. Kotlin puede ser usado en el back-end (lado del servidor), pero está teniendo mucha atención justo ahora como un lenguaje para desarrollo de aplicaciones Android. Kotlin es ahora soportado por Google como lenguaje de primera clase para desarrollo Android, ¡así que la popularidad de Kotlin está por explotar!

En este primer tutorial en la serie Kotlin Desde Cero, aprenderás sobre los básicos del lenguaje: comentarios, variables, tipos simples, arreglos, e interfaz tipo.

Prerrequisitos

Para seguir junto conmigo, necesitarás el complemento Kotlin en Android Studio. De manera alternativa, podrías usar el patio de juegos en línea o IntelliJ IDEA Community Edition.

1. Variables

En Kotlin, usa las palabras clave val para declarar una constante o var para declarar una variable. Puedes especificar un tipo tal como String o Int después del nombre de la variable. En el ejemplo de abajo, declaramos una constante firstName de tipo String con la palabra clave val.

1	val firstName: String = "Chike"

Pero pronto te darás cuenta de que en Kotlin, es frecuentemente posible omitir el tipo de la declaración y el compilador no se quejará.

1	val lastName = "Mgbemena" // will still compile

En el código de arriba, observarás que no declaramos de manera explícita el tipo String. El código de arriba aún funcionará porque el compilador ha inferido de manera implícita el tipo usando interfaz tipo. ¡Regresaremos a esto!

La diferencia entre las palabras clave val y var es que el primero es inmutable o de solo lectura (su valor no puede ser cambiado), mientras que el último es mutable (su valor puede ser cambiado).

val dateOfBirth = "29th March, 1709" 
dateOfBirth = "25th December, 1600" // cannot be changed

var car = "Toyota Matrix"
car = "Mercedes-Maybach" // can be changed

Nota que para una variable declarada con la palabra clave var la cuál tiene su tipo inferido por el compilador, asignar otro valor a un tipo diferente no funcionará. En otras palabras, el valor de la variable puede cambiar, ¡pero su tipo no! Por ejemplo:

1	var age = 12
2	age = "12 years old" // Error: type mismatch

Es altamente recomendable que comiences haciendo tus variables inmutables declarándolas con la palabra clave val, de modo que no mantenga demasiados estados. Esto hace a tu código más seguro para procesamiento múltiple, porque asegura que tus variables no pueden ser modificadas por otros hilos de manera inesperada.

Otra cosa que deberías saber sobre la palabra clave val es que puedes declararla con solo un tipo y asignarle un valor después. Pero aún puedes asignar solo un valor una vez.

1	val carName: String
2	carName = "Toyota Matrix" // will compile

En Java, es posible declarar múltiples variables del mismo tipo en una sola línea, pero esto no funcionará en Kotlin. En Kotlin, todas las declaraciones de variable deben estar en sus propias líneas.

val carName = "BMW", streetName = "Oke street" // this won't compile

// this will compile
var carName = "BMW"
var streetName = "Oke street"

2. Interfaz Tipo o Deducción

Kotlin es un lenguaje fuertemente tipado que soporta interfaz tipo o deducción. Este es el mecanismo empleado por el compilador para averiguar tipo desde contexto. Java no tiene un mecanismo de interfaz tipo, lo que significa que debes declarar explícitamente el tipo de cada función o variable. La interfaz tipo ayuda a reducir el código que tienes que escribir.

1	val country = "Nigeria" // type is inferred by compiler
2	val code = 234

El código de arriba compilaría incluso aunque no declaramos de manera explícita el tipo para la variable país. El compilador es lo suficientemente inteligente para saber que el país es de tipo String, porque el valor, "Nigeria", es una cadena de texto.

3. Tipos Básicos

En Java, tenemos dos tipos de tipo---primitivo (ej. int, long, boolean, byte, char, etc.) y tipos de referencia (ej. array, String). Java usa envoltorios (como java.lang.Integer) para hacer que los tipos primitivos se comporten como objetos. Pero en Kotlin, no hay tal distinción. En su lugar, todos los tipos son objetos.

Números

Los tipos enteros disponibles en Kotlin son:

Long—64 bit
Int—32 bit
Short—16 bit
Byte—8 bit

Los tipos de punto flotante son:

Double—64 bit
Float—32 bit

val myInt = 55
val myLong = 40L
val myFloat = 34.43F
val myDouble = 45.78
val myHexadecimal = 0x0F
val myBinary = 0b010101

Puedes observar que creamos un literal Long agregando el sufijo L, y para Float agregamos el sufijo F o f. Los números también pueden ser escritos en notación hexadecimal usando el prefijo 0x o 0X y en binario usando el prefijo 0b o 0B. Nota que en todos estos casos, Kotlin puede usar interfaz tipo para saber el tipo que queremos en su lugar.

1	val myLong = 19L
2	val myLongAgain: Long = 40

Para convertir un número desde un tipo a otro, tienes que invocar de manera explícita la función de conversión correspondiente. En otras palabras, no hay conversión implícita entre tipos de números.

1	val myNumber = 400
2	val myNumberAgain: Long = myNumber // throws Error: Type mismatch

Cada tipo de número tiene funciones de ayuda que convierten de un tipo de número a otro: toByte(), toInt(), toLong(), toFloat(), toDouble(), toChar(), toShort().

1	val myInt = 987
2	val myLong = myInt.toLong()

En el código de arriba, estamos convirtiendo desde un entero a un long. También podemos hacer lo inverso usando el método toInt() en la variable long. Nota que esto truncará el valor para encajar el tamaño más pequeño en un tipo Int si es necesario---¡así que ten cuidado cuando conviertas desde tipos más grandes a más pequeños!

También puedes convertir un String en un tipo número.

1	val stringNumber = "101"
2	val intValue = stringNumber.toInt()

En el código de arriba, convertimos la variable stringNumber a un tipo Int llamando al método toInt() en la variable. Podemos escribir esto más sucintamente llamando en su lugar el método directamente sobre la cadena:

1	val intValue = "101".toInt()

A Tipo Booleano

El tipo Boolean en Kotlin es el mismo que en Java. Su valor puede ser verdadero o falso. Los operadores disyunción (||), conjunción (&&), y negación (!) pueden ser ejecutados sobre tipos booleanos, justo como Java.

val myTrueBoolean = true
val myFalseBoolean = false

val x = 1
val y = 3
val w = 4
val z = 6

val n = x < z && z > w // n is true

Cadenas

Las cadenas pueden ser creadas ya sea con comillas dobles o comillas triples. Adicional a es, los caracteres de escape pueden ser usados con comillas dobles.

1	val myString = "This is a String"
2	val escapeString = "This is a string with new line \n"

Para crear una cadena que se extienda múltiples líneas en el archivo fuente, usamos comillas triples:

1	val multipleStringLines = """
2	This is first line
3	This is second line
4	This is third line """

Kotlin también soporta interpolación de cadena o plantillas de cadena. Esta es una manera más sencilla de construir cadenas dinámicas que concatenación, que es lo que usamos en Java. Usando plantillas de cadena, podemos insertar variables y expresiones en una cadena.

1	val accountBalance = 200
2	val bankMessage = "Your account balance is $accountBalance" // Your account balance is 200

En el código de arriba, creamos una cadena literal, y dentro de esta, referimos a una variable por el uso de un caracter $ en frente del nombre de la variable. Nota que si la variable no es correcta o no existe, el código no se compilará.

¿Qué si necesitas usar $ en tu cadena? ¡Solo lo escapas con \$! También, puedes llamar métodos desde un String interpolado directamente; tienes que agregar llaves ${} para envolverlo.

1	val name = "Chike"
2	val message = "The first letter in my name is ${name.first()}" // The first letter in my name is C

Otra cosa genial que puedes hacer es ejecutar alguna lógica dentro de las llaves cuando creas un literal String.

1	val age = 40
2	val anotherMessage = "You are ${if (age > 60) "old" else "young"}" // You are young

Arreglos

En Kotlin, hay dos maneras principales de crear un arreglo: usando la función de ayuda arrayOf() o el constructor Array().

La Función `arrayOf()`

Por ejemplo, creemos un arreglo con algunos elementos usando arrayOf().

1	val myArray = arrayOf(4, 5, 7, 3)

Ahora, para acceder a cualquiera del elemento, podemos usar su índice: myArray[2]. nota que podemos pasar valores de diferentes tipos en el arrayOf() como argumentos y aún funcionará---será un arreglo de tipo mixto.

1	val myArray = arrayOf(4, 5, 7, 3, "Chike", false)

Para hacer cumplir que todos los valores del arreglo tienen el mismo tipo, ej. Int, declaramos un tipo llamando arrayOf<Int>() o intArrayOf().

1	val myArray3 = arrayOf<Int>(4, 5, 7, 3, "Chike", false) // will not compile
2	val myArray4 = intArrayOf(4, 5, 7, 3, "Chike", false) // will not compile

También tenemos otras funciones de utilidad para crear arreglos de otros tipos tales como charArrayOf(), booleanArrayOf(), longArrayOf(), shortArrayOf(), byteArrayOf(), y así por el estilo. Detrás de escenas, usar estas funciones creará un arreglo de sus respectivos tipos primitivos Java. En otras palabras, intArrayOf() compilará al tipo primitivo regular Java int[], byteArrayOf() será byte[], longArrayOf() será long[], y así por el estilo.

El Constructor `Array()`

Ahora veamos cómo crear un arreglo con Array(). El constructor de esta clase requiere un tamaño y una función lambda. Aprenderemos más sobre funciones lambda después en esta serie, pero por ahora, solo entiende que es una manera simple en línea de declarar una función anónima. En este caso, el trabajo de la función lambda es inicializar el arreglo con elementos.

1	val numbersArray = Array(5, { i -> i * 2 })

En el código de arriba, pasamos 5 como el tamaño del arreglo en el primer argumento. El segundo argumento toma una función lambda, la cuál toma el índice del elemento del arreglo y después devuelve el valor para ser insertado en ese índice en el arreglo. Así que en el ejemplo de arriba, creamos un arreglo con elementos 0, 2, 4, 6, y 8.

4. Comentarios

Este es uno fácil. En Kotlin, los comentarios son los mismos que en Java- Podemos usar ya sea comentarios de bloque o de línea:

/*
 hello, this is a block comment
 with multiple lines.
 This is another line.
 This is another one again
*/

// this is a single line comment

Conclusión

En este tutorial, aprendiste los básicos del lenguaje de programación Kotlin: variables, tipos básicos, interfaces de tipo, arreglos y comentarios. En el siguiente tutorial en la serie Kotlin Desde Cero, aprenderás sobre ciclos, rangos, condiciones, colecciones y paquetes en Kotlin. ¡Nos vemos pronto!

Para aprender más sobre el lenguaje Kotlin, recomiendo visitar la documentación Kotlin. O revisa algunos de nuestros otros tutoriales Kotlin aquí en Envato Tuts+.