No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Lambdas

28/37
Recursos

Aportes 16

Preguntas 1

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

Hola tratando de comprender un poco mejor la sintaxis de la Lambda realic茅 este ejemplo:

Aunque no tiene que ver con Kotlin, pero si est谩n aqu铆 por la carrera de Android es muy recomendable ver el curso de Programaci贸n funcional con Java. https://platzi.com/clases/java-funcional/

C贸digo de la clase 馃槂

fun main(args:Array<String>){
    val myLambda : (String) -> Int = {
        //it es el parametro que estamos pasando
        valor -> valor.length
    }
    val lambdaEjecutar = myLambda("David")
    println(lambdaEjecutar)

    val saludos = listOf("Hola","Ciao")
    val longitudSaludos = saludos.map(myLambda)
    println(longitudSaludos)
}

Lambdas:
Las conocemos en otros lenguajes como funciones an贸nimas o funciones literales

Funciones an贸nimas: lo declaramos una funci贸n que no tiene nombre
Una lambda es tan solo una forma de escribir una funci贸n, m谩s simplificada





El uso de lambdas es muy util para operar listas en un map y no reptir el contenido de la operaci贸n.

Ejemplo:

fun main(args: Array<String>) {
	// declaraci贸n de lambda
	val myLambda: (String) -> Int = {
		valor -> valor.length
	}
	
	// invocar lambda y ejecutar.
	val lambdaEjecutado: Int = myLambda('hola platzi')
	println(lambdaEjecutado)
	
	// utilizar la lambda, esto es muy util cuando quieres hacer una operaci贸n en diferentes listas, para no estar repitiendo c贸digo.
	val saludos = ListOf('Hello', 'Hola', 'Ciao')
	val longitudDeSaludos = saludos.map(myLambda)
}

Ejemplos de declaraci贸n de Lambdas:

//Una lambda con tipos expl铆citos en todas partes. La lambda es la parte entre llaves, que se asigna a una variable de tipo (String) -> String (un tipo de funci贸n)
val upperCase1: (String) ->String={str: String -> str.uppercase()}

//Inferencia de tipo dentro de lambda: el tipo del par谩metro lambda se infiere del tipo de variable a la que est谩 asignado.
    val upperCase2: (String) -> String = {str -> str.uppercase()}

//Inferencia de tipo fuera de lambda: el tipo de variable se infiere del tipo del par谩metro lambda y el valor de retorno.
    val upperCase3 = {str: String -> str.uppercase()}

//No puede hacer ambas cosas a la vez, el compilador no tiene la posibilidad de inferir el tipo de esa manera.
    //val upperCase4: {str -> str.uppercase()}



//Para lambdas con un solo par谩metro, no tiene que nombrarlo expl铆citamente. En su lugar, puede utilizar la variable it impl铆cita. Esto es especialmente 煤til cuando se puede inferir el tipo (que suele ser el caso).
    val upperCase5: (String) -> String = {it.uppercase()}

//Si su lambda consta de una 煤nica llamada de funci贸n, puede usar punteros de funci贸n (: :).
    val upperCase6: (String) -> String = String::uppercase

    println(upperCase1("hello"))
    println(upperCase2("hello"))
    println(upperCase3("hello"))
    println(upperCase5("hello"))
    println(upperCase6("hello"))

Salida:

Lambdas
Las Lambdas son una expresion que hace una funcion y decimos que no tiene nombre.
{println(鈥淗ola Mundo鈥)}
var hola = {println(鈥淗ola Mundo鈥)}
hola()

Las funciones lambda (鈥渓ambdas鈥) son una forma sencilla de crear funciones ad-hoc (para un fin determinado). Las lambdas se pueden denotar de forma muy concisa en muchos casos gracias a la inferencia de tipos y la variable it impl铆cita.

Me parece favorable el uso de lambdas cuando queremos crear una funci贸n corta que haga alguna modificaci贸n en una lista, entero o string pasado. Con esto nos ahorramos tiempo de crear todo el cuerpo de una funci贸n tradicional.

val  MyLambda : (String) -> Int = {valor -> valor.length }
    val lambdaEjecutada: Int = MyLambda("hola")
    println(MyLambda)

    val saludos = listOf("Hello","Hola","Ciao")
    val longitudSaludos = saludos.map(MyLambda)

Es muy parecido a JavaScript 馃槸

A las lambdas tambi茅n se le conocen como funciones an贸nimas

Las funciones lamda son como las expresiones Lamda en C# o las funciones an贸nimas en javascript, que son como quien dice, funciones en l铆nea porque no se declaran, y est谩n en l铆nea con el c贸digo, cuando digo en l铆nea me refiero a que es algo similar si lo quieren ver as铆, a los estilos CSS inline cuando se usa la etiqueta style que van ahora si dentro dentro de la misma l铆nea donde va el elemento, y no son de bloque o declarados por fuera.

val eCount = "develou.com".count({ char:Char -> char == 'e' })
println(eCount)  //printn = 2

El predicado char -> char == 鈥榚鈥 se podr铆a leer como 芦al par谩metro char corresponde su resultado de igualdad con 鈥榚鈥樎.

Si vas a la implementaci贸n de count(), ver谩s que invoca nuestro lambda en un ciclo for:

Mi c贸digo 馃槂

// Lambdas
    val getLengthFromStringLambda : (String) -> Int = { value -> value.length }
    val someGreetingsInTheWorld = listOf(

	"Hello",
"Hola",
	"Ciao",
		"Bonjour", 
"Hallo",
 	"Ol谩", 
"Hej",
	 "Aloha", 
"Namaste", 
		"Salam", 
	"Ni Hao,"

)
    println(someGreetingsInTheWorld)
    // it automatically insert the string as lambda parameter
    val lengthOfSomeGreetingsInTheWorld = someGreetingsInTheWorld.map(getLengthFromStringLambda)
    println(lengthOfSomeGreetingsInTheWorld)

Encontr茅 esta imagen que me ayud贸 a aclara la sintaxis de las Lambdas 馃槂