William Schnaider Torres Bermon
Oscar David Paredes Ramirez
Gracias por compartir!
¿Cómo trabajar con null y nulabilidad en Kotlin?
En el emocionante mundo de la programación en Kotlin, manejar correctamente los valores nulos es fundamental. A diferencia de otros lenguajes, Kotlin implementa una seguridad de nulabilidad que permite a los desarrolladores escribir código más seguro y eficiente. En esta guía, exploraremos cómo gestionar y sacar provecho de los tipos nulables, conociendo las herramientas que Kotlin pone a nuestra disposición.
¿Qué son los tipos nulables?
Los tipos nulables son esenciales en Kotlin para manejar la posibilidad de valores nulos dentro de nuestras variables. En esencia, un tipo nulable es un tipo de dato que permite asignarle un valor null, utilizando un signo de interrogación al final del tipo. Por ejemplo, si tenemos una variable de tipo String?, esto indica que puede contener un String o ser null.
var nombre: String? = "Antonio" nombre = null // Esto es válido porque 'nombre' es un String nulable
¿Cómo utilizar los safe calls?
Las safe calls en Kotlin nos ayudan a evitar errores comunes que surgen al trabajar con variables nulables. Utilizando el operador de safe call (?.), podemos acceder a propiedades o métodos de manera segura solo si el objeto no es nulo. Así, el código se ejecutará si la variable no es nula, evitando errores inesperados.
val longitud = nombre?.length println(longitud) // Imprime la longitud solo si 'nombre' no es nulo
¿Cuándo evitar el operador "Double Bang"?
El operador "Double Bang" (!!) se utiliza en Kotlin para afirmar que una variable no es nula, y permite acceder a sus propiedades o métodos directamente. Sin embargo, su uso debe ser limitado, ya que si la variable resulta ser nula, se lanzará una excepción. Esta práctica suele ser considerada riesgosa y poco recomendable.
val longitudForzada = nombre!!.length // Usa con precaución; puede lanzar una NullPointerException
¿Cómo manejar la interoperabilidad de Kotlin con Java?
Cuando se trabaja en proyectos mixtos de Kotlin y Java, es común encontrarse con tipos no verificables por Kotlin. En estos casos, los tipos pueden aparecer con un símbolo de exclamación al final, señalando que Kotlin no puede determinar la nulabilidad de esos tipos. Es crucial tratar estos tipos retornados como si fueran nulables, ya que carecen de la seguridad de nulabilidad que el lenguaje proporciona.
¿Por qué la interoperabilidad puede suponer un riesgo?
En situaciones donde el código Java no gestiona adecuadamente los valores nulos, puede resultar en errores al integrarlo con Kotlin. Un ejemplo notable de estos errores son las "Null Pointer Exceptions". De ahí la importancia de tratar cualquier dato proveniente de Java como potencialmente nulable y manejarlo con precaución.
Esto configura un entorno donde comprender y manejar adecuadamente los valores nulos es más que un lujo, es una necesidad. Kotlin ofrece herramientas y prácticas que, usadas correctamente, aumentarán tanto la calidad como la eficiencia de tu código. Al usar Kotlin, siempre debemos considerar la seguridad de nulabilidad y los beneficios que nos ofrece para mantener aplicaciones robustas y sin fallos inesperados. Continúa explorando y mejorando tus habilidades, la siguiente clase abordará cómo manejar excepciones con estrategias avanzadas. Happy coding!
++HomeKotlinKotlin, Gestión de nulos (Null Safety)++ KOTLIN, GESTIÓN DE NULOS (NULL SAFETY) ++kotlin null safety++ En Kotlin los objetos por defecto no aceptan valores nulos, para que le podamos asignar un null tendremos que indicar que ese objeto realmente puede ser null. De esta forma vamos a poder garantizar que no se no producirá un NullPointerException en tiempo de ejecución sin necesidad de llenar todo el código de comprobaciones if (a != null) o if (b == null) cuando las variables no deban ser null en ningún caso, pero también nos da una vía de escape para que podamos tener los queridos NullPointerException.
++NULL SAFETY, NO MÁS NULLPOINTEREXCEPTION++ Kotlin es Null Safety, es decir, que gestiona los nulos de forma segura, de modo que puedes garantizar que tu código no va a producir NullPointerException.
Para empezar por defecto los objetos en Kotlin por defecto son not-null y si intentamos asignarle un null a una variable directamente no va a compilar.
var nombre: String nombre = null // Null can not be a value of a non-null type String Sin null todo es muy bonito pero está claro que muchas veces si queremos que los objetos sí que sean nullables, para esto tenemos que añadir ? después del nombre del tipo. var nombre: String? nombre = null var longitud: Int = nombre.length // Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?
Y seguimos buscandole las cosquillas a Kotlin para que nos dé un NullPointerException intentando sacar la longitud de la cadena cuando es null, pero no nos deja porque no compila y nos dice que tenemos 2 opciones ?. si queremos hacerlo de forma segura o !!. si no queremos que el compilador compruebe si puede ser null.
++DESACTIVAR COMPROBACIÓN DE NULOS++ Si optamos por !!. hacemos que el compilador no compruebe si puede ser null y por lo tanto compilará sin problemas, eso si el resultado de la ejecución no será demasiado bueno… No se me ocurre ningún motivo para utilizarlo, pero bueno hay esta por si echamos de menos los null pointers…
var nombre: String? = null var longitud: Int = nombre!!.length // Exception in thread "main" kotlin.KotlinNullPointerException
++LLAMADAS SEGURAS++ Lo lógico será que usemos ?. para que no falle. Si como en nuestro ejemplo el objeto es null cuando se intente sacar la longitud del nombre en lugar de lanzarse una excepción lo que sucederá es que devolverá null y por lo tanto nuestra variable longitud tiene que ser nullable para que compile correctamente. Si ejecutemos este código longitud es null.
var nombre: String? = null // var longitud: Int = nombre?.length // Type mismatch: inferred type is Int? but Int was expected var longitud: Int? = nombre?.length println("Longitud: ${longitud}") // Longitud: null
++EL OPERADOR ELVIS ( ?: )++ Si solo usamos ?. siempre vamos a poder recibir un null y por lo tanto estamos propagando a los siguientes objetos o funciones la necesidad de soportar nulos, pero puede que no sea lo que queramos. Para evitar esto podemos usar el operador Elvis ?: que nos permite definir un valor alternativo si se encuentra un null, por ejemplo para la longitud podríamos usar 0.
var nombre: String? = null var longitud: Int = nombre?.length ?: 0 println("Longitud: ${longitud}") // Longitud: 0
++SACAR LOS VALORES DISTINTOS DE NULL DE UNA LISTA++ Si tenemos una lista (o cualquier otro tipo de Collection) que tenga valores nulos, podemos filtrarlos fácilmente con la función .filterNotNull() para obtener solo los valores distintos de null.
val listaConNulls: List = listOf(null, 2, null, 4, null) println("Con nulls: ${listaConNulls}") // Con nulls: [null, 2, null, 4, null] val listaSinnNulls: List = listaConNulls.filterNotNull() println("Sin nulls: ${listaSinnNulls}") // Sin nulls: [2, 4]
Y bueno aunque no lo he puesto se puede comprobar si un objeto es null o no utilizando if-else, pero si hay formas más sencillas de hacerlo ¿porque utilizarlos?
fuente: https://programandoointentandolo.com/2018/02/kotlin-gestion-nulos-null-safety.html
William Schnaider Torres Bermon
Oscar David Paredes Ramirez
Gracias por compartir!
Silvana Rolón
Cristian David Restrepo Marin
👍
Jesus Cuadro
Muchas gracias
Jorge Trad
Cristian David Restrepo Marin
👍
Reinaldo Mendoza
buen resumen
Marcos Forastiere
dejo este link donde se explica y hay ejemplo de uso de null. https://developer.android.com/codelabs/basic-android-kotlin-compose-nullability?hl=es-419#1
Braulio Hernandez
Llamada segura mediante operador ?.
Kotlin nos ofrece el operador ? de cara a reducir ese código, de modo que podemos tener la comprobación de null y la llamada al método en la misma línea. De este modo, el siguiente código:
nombre?.toUpperCase()
Es lo mismo que:
if (nombre != null) nombre.toUpperCase() else null
Cristian David Restrepo Marin
👍
henrique araujo
https://developer.android.com/codelabs/basic-android-kotlin-compose-nullability?hl=es-419#1 chéquense aquí si no les quedo claro lo de null
john fredy quimbaya orozco
Lean el libro Clean Arquitecture hay principios de diseño de software es bueno
Carlos Ivan Garcia Fougerat
Cuando declaras una variable de forma predeterminada, su valor no puede ser null. . Kotlin nos ayuda a evitar las excepciones, se usa el operador ? para que una variable puede ser una nula. . var variable: Int? = null
Carlos Eduardo Repillosa Del Valle
Los errores que generan los null son los mas dificiles de corregir ya que solo ocurren en tiempo de ejecucion o en produccion, por lo cual toda validacion y herramienta que te brinde el lenguaje para evitarlo siempre debe ser usada para evitar problemas a largo plazo y hacer el codigo mas legible.
Jerson Jacinto Blas
si mi programa que esta cloud y se genera un null por un usuario? mi pagina dejara de funcionar para todos ?
Diego Alejandro Pardo Montero
¿Por qué cree que fue un error crear el tipo null? ¿No hubo una intención justificada cuando lo hizo?
Giuseppe Vetri
ProfesorLe paso como a muchos devs cuando estan enfrentandose a un problema, "Lo soluciono despues dijo" y asi se quedo 😅
Gabriel Caro
alguien también no puede ver la clase 17?
Jesus Cuadro
Valores nulos, double bang y como solucionarlos
los null no son malos, son incomprendidos
Como toda herramienta puede ser mal utilizada o bien utilizada.
Como declaramos un tipo que puede ser nulo
Para esto debemos utilizar el simbolo de interrogacion despues del tipo de dato que queremos utilizar.
// Utilizando el null: var segundoNombre : String? = "Jesus"
El compilador es tu amigo, no tu enemigo
El compilador es capaz de interpretar estos tipos. Y advertirnos de lo que puede ocurrir al correr nuestro programa.
Crea codigo para otros
Crea codigo como si tuvieras que trabajar en ello dentro de un año.
Esto te ayudará a pensar en una solucion a futuro y no solo en complacer el compilador.
Safe Calls
Las safe calls son una herramienta del lenguaje que nos ayudan a ejecutar un codigo cuando una variable del tipo nullable no es nula.
// Utilizando los safe-calls println(segundoNombre?.length())
Double bang
Este operador se indica con dos simbolos de exclamacion !! Con esto le dices al compilador que sabes que en este punto la variable no puede ser nula.
Gran poder, gran responsabilidad
No esta bien usarlo siempre para que tu codigo compile y ya.
Usalo solo cuando sea necesario y sepas que esa variable no sera nula en ese punto.
Interoperabilidad con JAVA
Al ejecutar codigo escrito por otras personas en JAVA desde Kotlin. Puede que te encuentres con estos tipos de variable: Integer!
Los tipos Integer! Son la forma que tiene Kotlin de avisarte que no puede asegurarse de que ese codigo no devuelva null. Como recomendacion siempre tratalos como nullables.
Juan Bautista
gracias por la explicacion sobre null safety, me sirve mucho para flutter en sus ultima versiones
Alejandra Morataya
Si no les queda claro, les recomiendo esta lectura. A mi me sirvió mucho https://programandoointentandolo.com/2018/02/kotlin-gestion-nulos-null-safety.html
John Alassio
Por fin Kotlin!
John Alassio
Vengo de Java O.O y de Funcional con Java y de String a medias... pero esto puuuuf es la pegada! como que evitamos los null en la app? que demas ame Java... ahora amo a KOtlin
Luis Guzmán
la llamada la length es sin paréntesis
//safe-calls println(segundoNombre?.length)
FABRIZIO VITORINO MONJARAS
En kotlin por defecto nigun valor puede ser nulo. Nos marcar un error. El operador Double Bang se utiliza pocas veces en kotlin y es preferible no usarlo
Kotlin maneja los valores nulos de manera segura para evitar errores comunes de NullPointerException en tiempo de ejecución. Kotlin utiliza el concepto de "nullabilidad" para permitir o prohibir que una variable tenga un valor nulo. . En Kotlin, los tipos de datos se dividen en dos categorías: tipos nulos y tipos no nulos. Un tipo no nulo se denota simplemente escribiendo el nombre del tipo, como String. Un tipo nulo se denota escribiendo el nombre del tipo seguido de un signo de interrogación, como String?. . Cuando declaramos una variable como un tipo nulo, podemos asignarle un valor nulo o un valor del tipo correspondiente, mientras que una variable de un tipo no nulo solo puede tener un valor del tipo correspondiente. Si intentamos asignar un valor nulo a una variable de un tipo no nulo, se generará un error de compilación. . Para acceder a una variable de tipo nulo, Kotlin ofrece el operador de "seguridad de nulos", denotado por el signo de interrogación. Este operador nos permite verificar si una variable es nula antes de intentar acceder a sus propiedades o métodos, evitando así que se genere un error en tiempo de ejecución. Por ejemplo:
val s: String? = null
// El siguiente código genera un error de compilación porque s es nulo // val length = s.length // El siguiente código funciona porque se usa el operador de seguridad de nulos para verificar si s es nulo antes de acceder a su propiedad length val length = s?.length
Kotlin también ofrece el operador de "elvis" para proporcionar un valor predeterminado en caso de que una variable sea nula. El operador de elvis se denota por el signo de interrogación seguido de dos puntos, y se utiliza en una expresión como la siguiente:
val s: String? = null val length = s?.length ?: 0 // Devuelve 0 si s es nulo
En resumen, Kotlin maneja los valores nulos de manera segura mediante el concepto de nullabilidad, los operadores de seguridad de nulos y de elvis, lo que nos permite evitar errores comunes de NullPointerException en tiempo de ejecución.
Valores nulos, Double bang y cómo solucionarlos
Para solucionar errores nulleables, le decimos a las variables que declaremos que el valor puede ser null con un signo de interrogación...
var segundoNombre : String? = "Antonio"
Safe Calls
Nos ayuda a ejecutar un código cuando una variable del tipo nulleable no es nula
println(segundoNombre?.length)
Double Bang
Le indicamos al compilador que enn este punto la variable nno puede ser nula
var caracteres: Int = segundoNombre!!.length
Solo usalo cuando estes 100% seguro de que esta variable siempre tendrá un valor diferente a null. Peeeeero trata de evitarlo lo más posible.