Null Safety Kotlin (Seguridad contra nulos en Kotlin)

No sé si haya una traducción adecuada para este término, si encuentras una mejor, te agradezco que me la digas.

Comencemos, Kotlin es un lenguaje que busca eliminar las referencias nulas que se pueden producir al ejecutar un programa. Y evitar nuestro querido y bien conocido “Null Pointer Exception (NPE)”.

Como sabemos esta es una excepción runtime (es decir que solo se produce en tiempo de ejecución y no de compilación), por lo cual no se puede prever, aunque los IDE’s hoy en día nos lanzan advertencias de que podría producirse un NPE.

Esta excepción se suele producir debido a que cierto campo no fue inicializado, una asignación a nulo, un campo que por alguna razón perdió su asignación a un objeto o un método que nos retornó un nulo, que puede ser de un API, un ORM, un servicio web o cualquier fuente externa a nuestros código.

Bueno en Kotlin, los campos por defecto no pueden ser nulos, hagamos un ejemplo:

var nombre : String = ""
nombre = null // Error! A esta variable no se le puede asignar un valor null.

Si deseas asignar un nulo a una variable, la declaración sería así:

var apellido : String? = ""
apellido = null // Esto funciona!

Esta es la clave, el símbolo “?” equivale a decir, este campo puede ser nulo.

field1.contains("a")
field2.contains("b")

Puedes predecir los resultados de estas dos sentencias?

Si lo hiciste bien, pues la primera sentencia funciona sin problemas, la segunda falla, ya que al ser la variable “field2” nulleable, pues necesitas validar que esta no sea nula para poder hacer un contains o provocaría un error. La manera típica de hacerlo es:

val isCharContained = if (field2 != null) field2.contains("b") else false

Existe otra manera de hacerlo al estilo kotlin, usando el operador Elvis, así:

val isCharContained = field2?.contains("b")? : false

De esta manera, se puede asegurar que la función contains solo se ejecutará si el campo no es nulo. Caso contrario solo te devolverá un nulo. Ten en cuenta esto.

Recuerdas los bloques if cuando tenías muchas propiedades por verificar?

Considera este objeto:

Persona -> Profesión->Descripción (Una persona tiene una profesión y cada profesión tiene su descripción)

Método tradicional:

if(persona!=null)
 if(profesion!=null)
   if(descripcion!=null)
      descripcion.toString()

Kotlin, te permite hacerlo así

persona?.profesion?.descripcion?.toString()

Mejor, no?

Lo siguiente es el operador “!!” . Este operador es usado para las personas que por alguna razón tienen un vínculo emocional con el NPE (:P solo un chiste), al usar este operador, te va a retornar el resultado de la función que quisiste usar y en caso de que sea null. te va a lanzar un NPE.

apellido!!.contains("b")

Quizá te surja una pregunta, ¿Y en las listas, también debo declarar tipos que pueden ser nulos? La respuesta es: Si los necesitas, sí! Mira este pequeño ejemplo en el que tienes una lista de tipos nullables, y a partir de esta lista, obtienes una lista con tipos que no van a ser nulos.

val listaConValoresNulos: List<String?> = listOf("perro", "gato", null, "conejo") 
val listaSinValoresNulos: List<String> = listaConValoresNulos.filterNotNull()

Cuántos objetos tendría la lista de valores no nulos? Como seguramente dedujiste, son 3. Como claramente dice la función, filtra los valores no nulos, es decir que quita solo toma en cuenta aquellos que no sean nulos. Esto puede ser muy útil.

Un pequeño adicional, muchas veces hemos querido hacer “casteo” de objetos y muchas de esas veces ha resultado en un ClassCastException, pues este operador también puede ser usado para esto:

val direccion: String? = apellido as? Boolean

Esto va a devolver un nulo, porque no se puede castear. Esto evitaría que haya tu aplicación tenga errores ya que puedes controlarlo con esto y hacer que te devuelva algún valor por defecto o una excepción controlada tengas definida.

Bueno, eso ha sido todo sobre este tema? Recuerda, tu feedback es siempre bienvenido!