Siguiendo lo que aprendimos en la clase anterior, no tenemos que repetir el lambda dos veces (aunque entiendo que lo haya hecho así para explciarlo bien)

¿Qué son las scope functions en Kotlin?
Las scope functions en Kotlin son funciones especiales que ofrecen una sintaxis más limpia y concisa para realizar ciertas operaciones comunes. Estas funciones nos permiten manipular variables de manera más dinámica, sin necesidad de estar repitiendo el nombre de la variable continuamente. Gracias a estas funciones, podemos realizar modificaciones y ejecutar bloques de código bajo ciertas condiciones, optimizando nuestro trabajo con variables especialmente cuando manejamos tipos anulables.
¿Cómo utilizar la función let?
La función let es una de las Scope Functions más utilizadas en Kotlin, especialmente cuando trabajamos con variables anulables. El poder de let radica en su capacidad de ejecutar un bloque de código solo cuando una variable no es nula, lo cual nos ahorra posibles errores de ejecución derivados de un null pointer exception.
Implementación de let en Kotlin
Veamos cómo funciona:
var nombre: String? = null nombre?.let { valor -> println("El nombre no es nulo, es $valor") }
En este ejemplo inicial, nombre es una variable nula. Por lo tanto, el bloque de código dentro de let no se ejecutará debido a la condición de que nombre debe ser no nulo.
Supongamos que cambiamos el valor de nombre a un valor no nulo:
var nombre: String? = "Carlos" nombre?.let { valor -> println("El nombre no es nulo, es $valor") }
Aquí, el mensaje "El nombre no es nulo, es Carlos" se imprimirá porque ahora la variable contiene un valor no nulo.
¿Cuáles son las ventajas de usar let?
Control de flujo seguro: Permite ejecutar código solo cuando las variables no son nulas, lo que previene excepciones de tipo Null Pointer.
Legibilidad del código: Al especificar un parámetro como valor dentro de let, el código se vuelve más explícito y entendible para otros desarrolladores.
Facilita las asignaciones: Dentro de let, el valor de la variable se puede manipular de forma temporal y segura.
¿Qué consejos practicar con let?
Utiliza let con tipos anulables: Siempre que tengas una variable susceptible a ser nula, let es tu aliado para evitar errores inesperados.
Sé explícito con los nombres de parámetros: Al nombrar el parámetro dentro de let, mejora la comprensión del código como parte de una buena práctica de desarrollo.
Aprovecha las recomendaciones del IDE: Herramientas como IntelliJ pueden ofrecer sugerencias útiles mientras desarrollas, ayudándote a mejorar la eficiencia y seguridad del código.
Kotlin y sus scope functions, como let, te ofrecen una plataforma poderosa para escribir código más seguro y elegante. ¡Sigue explorando y practicando para dominar estos conceptos clave!
Las scope functions en Kotlin son funciones especiales que ofrecen una sintaxis más limpia y concisa para realizar ciertas operaciones comunes. Estas funciones nos permiten manipular variables de manera más dinámica, sin necesidad de estar repitiendo el nombre de la variable continuamente. Gracias a estas funciones, podemos realizar modificaciones y ejecutar bloques de código bajo ciertas condiciones, optimizando nuestro trabajo con variables especialmente cuando manejamos tipos anulables.
let?La función let es una de las Scope Functions más utilizadas en Kotlin, especialmente cuando trabajamos con variables anulables. El poder de let radica en su capacidad de ejecutar un bloque de código solo cuando una variable no es nula, lo cual nos ahorra posibles errores de ejecución derivados de un null pointer exception.
let en KotlinVeamos cómo funciona:
var nombre: String? = null
nombre?.let { valor ->
println("El nombre no es nulo, es $valor")
}
En este ejemplo inicial, nombre es una variable nula. Por lo tanto, el bloque de código dentro de let no se ejecutará debido a la condición de que nombre debe ser no nulo.
Supongamos que cambiamos el valor de nombre a un valor no nulo:
var nombre: String? = "Carlos"
nombre?.let { valor ->
println("El nombre no es nulo, es $valor")
}
Aquí, el mensaje "El nombre no es nulo, es Carlos" se imprimirá porque ahora la variable contiene un valor no nulo.
let?Control de flujo seguro: Permite ejecutar código solo cuando las variables no son nulas, lo que previene excepciones de tipo Null Pointer.
Legibilidad del código: Al especificar un parámetro como valor dentro de let, el código se vuelve más explícito y entendible para otros desarrolladores.
Facilita las asignaciones: Dentro de let, el valor de la variable se puede manipular de forma temporal y segura.
let?Utiliza let con tipos anulables: Siempre que tengas una variable susceptible a ser nula, let es tu aliado para evitar errores inesperados.
Sé explícito con los nombres de parámetros: Al nombrar el parámetro dentro de let, mejora la comprensión del código como parte de una buena práctica de desarrollo.
Aprovecha las recomendaciones del IDE: Herramientas como IntelliJ pueden ofrecer sugerencias útiles mientras desarrollas, ayudándote a mejorar la eficiencia y seguridad del código.
Kotlin y sus scope functions, como let, te ofrecen una plataforma poderosa para escribir código más seguro y elegante. ¡Sigue explorando y practicando para dominar estos conceptos clave!
Siguiendo lo que aprendimos en la clase anterior, no tenemos que repetir el lambda dos veces (aunque entiendo que lo haya hecho así para explciarlo bien)

++La Función let { }++ La función let es una función que crea un alcance temporal para un objeto en el interior de un bloque de código.
Esto quiere decir, que puedes referirte al objeto sin usar su nombre debido a que es el parámetro de la función lambda pasada a let.
inline fun <T, R> T.let(block: (T) -> R): R
Lenguaje del código: HTML, XML (xml) Como vez en su declaración, let:
Es una función genérica con argumentos T y R
Es una función inline
Es una función de extensión del tipo recibidor T
Recibe como parámetro un tipo función (T) -> (R)
Retorna como resultado a R Ya que let ejecuta a block pasando la expresión this del objeto recibidor, es como si crearas un espacio de escritura para tus sentencias asociadas al objeto.
val resultado = objeto.let{
/* sentencias y retorno de valor */
}
Lenguaje del código: Kotlin (kotlin) Ejemplo: Función let Para Mapear Supongamos que tenemos una clase para las facturas junto a otra que representa las líneas que están en ella:
class InvoiceLine(val unitCost: Double)
class Invoice(val customer: String, val lines: List<InvoiceLine>)
Lenguaje del código: Kotlin (kotlin) Ahora deseamos leer una factura y formatear las propiedades de la misma para mostrarlas en pantalla.
fun main() {
val invoice = Invoice(
"Fabricia",
listOf(
InvoiceLine(5.0),
InvoiceLine(4.0),
InvoiceLine(6.0)
)
)
val invoiceDetail = invoice.let {
val total = it.lines.sumOf { line -> line.unitCost }
"La factura de ${it.customer} tiene un total de $total"
}
println(invoiceDetail)
}
Salida:
La factura de Fabricia tiene un total de 15.0
Como puedes notar, al invocar a invoice.let{}, el parámetro del lambda será invoice, por lo que podemos usar a it como referencia.
Con esta forma podemos obtener el total de la factura a través de it.lines.sumOf{} y construir un String resultante con it.customer.
El objetivo es crear un contexto que te permita mejorar la legibilidad del propósito de tu código.
Ejemplo: Función let Y Tipos Anulables La función let también es de utilidad para ejecutar sentencias sobre tipos anulables en conjunto con el operador de acceso seguro(.?).
Si el objeto recibidor no es null, entonces las sentencias del lambda que pasaste como bloque de código son ejecutadas, de lo contrario no habrá acción.
Por ejemplo, ¿que pasaría si la factura leída fuese nula e intentaras imprimir su detalle?:
fun main() {
val invoice: Invoice? = null
val invoiceDetail = invoice?.let {
val total = it.lines.sumOf { line -> line.unitCost }
"La factura de ${it.customer} tiene un total de $total"
}
println(invoiceDetail)
}
Resultado:
null
Lenguaje del código: JavaScript (javascript) La función let tratará a invoice como si fuese no aceptara nulos en todo el alcance del lambda, de esta forma te evitas la comprobación de nulidad en cada línea del bloque de código.
Y si es null, entonces el parámetro block de let() no será ejecutado.

Código de la clase
fun main(args: Array<String>){
//Let ejecuta código cuando el valor no es nulo
var nombre: String? = null
nombre?.let{
//Código no se ejecutara al ser la variable nula
valor -> println("El nombre no es nulo es $valor")
}
nombre = "David"
nombre?.let{
//Código se ejecutara
valor -> println("El nombre no es nulo, es $valor")
}
}
?.let nos permite correr el código para un valor que no es nulo
Entiendo, pero en teoría el NullPointerException, no debería salir ya que Kotlin es null safety verdad? Corrigeme si me equivoco por favor
En el ejemplo escribe dos veces el mismo código para let, ¿ como podría dejarlo escrito una sola vez y llamarlo en ambos?
Lo que entendí.
Al ejecutar nombre?.let { /* CODIGO A EJECUTAR */ } despues del safe call ?. seria como ejecutar
if (nombre != null) {
/* CODIGO A EJECUTAR */
}
Imprimir los numeros pares usando let
fun main() {
var numero : Int? = null
val mensajePar : (Int) -> String = { "$it es par" }
for (i in (0..20)) {
if (i % 2 == 0)
numero = i
else
numero = null
numero?.let {
println(mensajePar(i))
}
}
}
Saludos,
Intenté hacer una función que reciba un String o Null y que en el return aplique let, alguien sabe ¿cómo debería ser la forma correcta de escribirla?
fun main() {
}
fun letFun( name : String? ) : String? {
val myLambda : (String?) -> String? = { value -> println("The name is: $value") }
return name.let(myLambda)
}
//Consola = Type mismatch: inferred type is Unit but String? was expected