Android Academy · Lección

Funciones y lambdas

Defina funciones con parámetros y tipos de retorno, utilice argumentos predeterminados y con nombre, y escriba expresiones lambda concisas.

Funciones y lambdas es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 3 lecciones en total.

¿Por qué usar funciones?

Las funciones permiten escribir un bloque de código una vez y reutilizarlo en cualquier lugar.

Reducen la duplicación
Facilitan la lectura y las pruebas del código
Dividen los problemas grandes en partes más pequeñas

En Kotlin, las funciones son ciudadanos de primera clase: puede almacenarlas en variables y pasarlas como argumentos.

Sintaxis básica de las funciones

Una función de Kotlin utiliza la palabra clave fun:

fun greet(name: String): String {
    return "Hello, $name!"
}

fun main() {
    val msg = greet("Alice")
    println(msg)  // Hello, Alice!

    println(greet("Bob"))  // Hello, Bob!
}

Funciones con una sola expresión

Cuando el cuerpo de una función consta de una sola expresión, puede usar = y omitir las llaves y return:

fun square(n: Int): Int = n * n

fun add(a: Int, b: Int) = a + b  // type inferred

fun main() {
    println(square(5))   // 25
    println(add(3, 7))   // 10
}

Argumentos predeterminados y con nombre

Las funciones de Kotlin admiten valores de parámetros predeterminados, por lo que no necesita sobrecargas:

Predeterminado: fun greet(name: String = "World")
Con nombre: llame a greet(name = "Alice") para no depender del orden posicional

Argumentos predeterminados y con nombre en acción

Los argumentos predeterminados mantienen limpia su API:

fun buildProfile(
    name: String,
    age: Int = 0,
    role: String = "User"
): String {
    return "$name | age=$age | $role"
}

fun main() {
    println(buildProfile("Alice"))
    println(buildProfile("Bob", age = 30))
    println(buildProfile("Carol", 25, "Admin"))
}

¿Qué son las lambdas?

Una lambda es una función anónima, es decir, una función sin nombre.

Sintaxis: { params -> body }
Se almacena en una variable: val double = { x: Int -> x * 2 }
Se pasa a otra función como argumento

Las lambdas están presentes en todo Android: listeners de clics, transformaciones de listas y corrutinas.

Ejemplos de lambdas

Almacene y llame lambdas igual que funciones normales:

fun main() {
    val double = { x: Int -> x * 2 }
    println(double(4))   // 8

    val add = { a: Int, b: Int -> a + b }
    println(add(3, 5))   // 8

    // Lambda with no params
    val sayHi = { println("Hi!") }
    sayHi()              // Hi!
}

Funciones de orden superior

Una función de orden superior recibe otra función como parámetro o devuelve una.

La biblioteca estándar de Kotlin está llena de ellas: filter, map y forEach.

Sintaxis de lambda final: cuando el último argumento es una lambda, muévala fuera de los paréntesis.

Sintaxis de lambda final

Pase una lambda como último argumento, fuera de los paréntesis:

fun applyTwice(n: Int, operation: (Int) -> Int): Int {
    return operation(operation(n))
}

fun main() {
    val result = applyTwice(3) { x -> x * 2 }
    println(result)  // 12  (3 * 2 = 6, 6 * 2 = 12)

    // 'it' is the implicit single parameter
    val doubled = applyTwice(5) { it + it }
    println(doubled) // 20
}

Comprobación rápida

Observe este código. ¿Qué imprimirá?

val triple = { x: Int -> x * 3 } println(triple(4))

Resumen: funciones y lambdas

Ha aprendido lo siguiente:

fun define una función con parámetros y tipo de retorno
Las funciones con una sola expresión usan la forma abreviada con =
Los argumentos predeterminados y con nombre sustituyen a las sobrecargas
Las lambdas son funciones anónimas: { params -> body }
Las funciones de orden superior aceptan funciones como parámetros

A continuación: controlará el flujo del programa con condiciones y bucles.

Preguntas frecuentes

¿La lección «Funciones y lambdas» es gratis?

Sí — el texto completo de «Funciones y lambdas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Funciones y lambdas»?

Defina funciones con parámetros y tipos de retorno, utilice argumentos predeterminados y con nombre, y escriba expresiones lambda concisas. Practicas Android Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Android Academy?

No se requiere experiencia previa. Android Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.

¿Cuánto tiempo toma la lección «Funciones y lambdas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Android Academy?

Sí. Cada lección de Android Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Android Academy