No tienes acceso a esta clase

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

Compra acceso a todo Platzi por 1 a帽o

Antes: $249

Currency
$209/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

16D
5H
34M
51S

Lambdas

28/37
Recursos

Aportes 22

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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





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:

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)
}

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.

Una cuesti贸n sintactica no menor, a mi entender, es que las lambdas no son pasadas o usadas como 鈥減arametro鈥 sino que son pasadas o usadas como 鈥渁rgumento鈥.

La diferencia radica en que parametro es la variable definida en una declaraci贸n de funci贸n mientras que argumento es el valor realmente pasado cuando se llama a esta funci贸n. As铆 es que:

package parametrosYArgumentos

fun main() {
    imprimirNombre(nombre = "Mariano", segundoNombre = "Daniel", apellido = "Gobea") // Argumentos
}

fun imprimirNombre (nombre: String, segundoNombre: String = "", apellido: String) { // Parametros 
    println("Mi nombre completo es $nombre $segundoNombre $apellido")
}

Espero sirva a la aclaraci贸n y que lo corrijan en el curso. Gracias!

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)
Muy parecido a python `val sumar : (Int,Int) -> Int = { x,y -> x + y }` `println``(sumar(2,9))`

Una lambda en Kotlin es una funci贸n an贸nima que puede ser tratada como un objeto. Se utiliza principalmente para crear funciones de orden superior, es decir, funciones que pueden recibir otras funciones como par谩metros o devolverlas como resultado. Una lambda se compone de una lista de par谩metros opcionales, una flecha 鈥->鈥 y un cuerpo de funci贸n.

Tambien se pudo haber ejecutado la funcion dentro del print de la siguiente manera:

println(myLambda("Hola"))

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)

no son como las arrow functions de JavaScript?

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:

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

Una funci贸n lambda es un literal de funci贸n que puede ser usado como expresi贸n. Esto quiere decir, una funci贸n que no est谩 ligada a un identificador y que puedes usar como valor.

Por ejemplo, si tenemos la funci贸n f(s) = s + 2, en Kotlin podemos expresarla como una declaraci贸n de funci贸n separada, as铆:

fun sumarDos(s: Int) = s + 2
Al ser reescrita como lambda, tendr铆as lo siguiente:

{s:Int -> s + 2}
Definir la funci贸n de esta forma te permitir谩 usarla como un valor en diferentes situaciones, como pasarla como argumento de una funci贸n o almacenarla en una variable.

La sintaxis de un literal lambda va al interior de dos llaves {}. Sus componentes son:

Lista de par谩metros 鈥 Cada par谩metro es una declaraci贸n de variable, aunque esta lista es opcional
Operador de flecha -> 鈥 Se omite si no usas lista de par谩metros
Cuerpo del lambda 鈥 Son las sentencias que van luego del operador de flecha
Sintaxis De Expresiones Lambda En Kotlin
La anterior sintaxis de la imagen se puede leer como 芦para cada par de s y t corresponde el valor 2*(s+t)芦