Android Academy · Lección

Funciones de extensión y de orden superior

Funciones de extensión y de orden superior es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 4 de 4. 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 4 lecciones en total.

Funciones de extensión

Una función de extensión permite añadir funciones a clases existentes sin modificarlas ni usar herencia. Puede extender String, Int, sus propias clases o incluso la clase View de Android.

Sintaxis: fun TypeName.functionName() { }

Escribir funciones de extensión

Dentro de una función de extensión, this hace referencia al objeto receptor:

fun String.isPalindrome(): Boolean {
    val cleaned = this.lowercase().filter { it.isLetter() }
    return cleaned == cleaned.reversed()
}

fun Int.isEven() = this % 2 == 0

fun main() {
    println("racecar".isPalindrome())  // true
    println("hello".isPalindrome())    // false
    println(4.isEven())                // true
    println(7.isEven())                // false
}

Funciones de extensión en vistas de Android

Patrón habitual de Android: oculte o muestre vistas con una extensión en lugar de repetir código repetitivo:

import android.view.View

fun View.show() { visibility = View.VISIBLE }
fun View.hide() { visibility = View.GONE }
fun View.invisible() { visibility = View.INVISIBLE }

// Usage in Activity:
// binding.progressBar.show()
// binding.recyclerView.hide()

Funciones de orden superior

Una función de orden superior recibe una función como parámetro o devuelve una función. Ya las ha utilizado: filter, map y forEach son funciones de orden superior.

Sintaxis del tipo de función: (ParamType) -> ReturnType

Pasar funciones como parámetros

Defina una función que acepte otra función:

fun operate(a: Int, b: Int, op: (Int, Int) -> Int): Int {
    return op(a, b)
}

fun main() {
    val sum  = operate(3, 4) { x, y -> x + y }
    val prod = operate(3, 4) { x, y -> x * y }
    val max  = operate(3, 4, ::maxOf)   // method reference

    println(sum)   // 7
    println(prod)  // 12
    println(max)   // 4
}

Devolver funciones

Las funciones también pueden devolver otras funciones, lo que resulta útil para crear comportamientos configurables:

fun makeMultiplier(factor: Int): (Int) -> Int {
    return { number -> number * factor }
}

fun main() {
    val double = makeMultiplier(2)
    val triple = makeMultiplier(3)

    println(double(5))   // 10
    println(triple(5))   // 15

    val numbers = listOf(1, 2, 3, 4)
    println(numbers.map(double))  // [2, 4, 6, 8]
}

Funciones de ámbito: let

Las funciones de ámbito de Kotlin ejecutan un bloque sobre un objeto y devuelven un resultado. let se utiliza para comprobaciones de valores nulos y transformaciones:

fun main() {
    val name: String? = "Alice"

    // Only runs if name is not null
    name?.let {
        println("Name length: ${it.length}")
        println("Upper: ${it.uppercase()}")
    }

    // Transform a value
    val length = name?.let { it.length } ?: 0
    println("Length: $length")  // 5
}

Funciones de ámbito: apply y also

apply configura un objeto y devuelve el objeto. also realiza un efecto secundario y devuelve el objeto:

data class Config(var host: String = "", var port: Int = 0, var timeout: Int = 0)

fun main() {
    // apply: configure an object (this = receiver)
    val config = Config().apply {
        host = "api.example.com"
        port = 443
        timeout = 30
    }
    println(config)  // Config(host=api.example.com, port=443, timeout=30)

    // also: log or debug (it = receiver)
    val result = listOf(1, 2, 3)
        .also { println("Original: $it") }
        .map { it * 2 }
        .also { println("Doubled: $it") }
}

Funciones de ámbito: run y with

run ejecuta un bloque sobre un objeto y devuelve el resultado del bloque. with es similar, pero no es una extensión:

data class User(val name: String, val age: Int)

fun main() {
    val user = User("Bob", 30)

    // run: compute something using the object
    val greeting = user.run {
        if (age >= 18) "Hello, $name!" else "Hi, $name!"
    }
    println(greeting)  // Hello, Bob!

    // with: group operations on an object
    val info = with(user) {
        "Name: $name, Age: $age"
    }
    println(info)  // Name: Bob, Age: 30
}

Guía rápida de las funciones de ámbito

Referencia rápida para elegir la función de ámbito adecuada:

let: bloque seguro frente a valores nulos, transforma el objeto y devuelve el resultado de la lambda
apply: configura el objeto y devuelve el objeto (this)
also: efectos secundarios (registro) y devuelve el objeto (it)
run: calcula un resultado a partir del objeto y devuelve el resultado de la lambda
with: agrupa llamadas sobre un objeto; no es una extensión

Funciones inline y reified

Marque una función de orden superior como inline para evitar la creación de objetos lambda durante la ejecución. reified permite usar el tipo genérico T durante la ejecución (normalmente se borra):

inline fun <reified T> Any.isOfType(): Boolean = this is T

fun main() {
    println("hello".isOfType<String>())   // true
    println(42.isOfType<String>())         // false
    println(3.14.isOfType<Double>())       // true
}

Comprobación rápida

¿Qué función de ámbito es la más adecuada para configurar un objeto recién creado y devolver ese mismo objeto?

Resumen: extensiones y funciones de orden superior

Ahora dispone del conjunto de herramientas funcionales de Kotlin:

Funciones de extensión: añaden comportamiento a cualquier tipo sin herencia
Funciones de orden superior: pasan y devuelven funciones para crear API flexibles
Funciones de ámbito: let (comprobación de valores nulos), apply (configuración), also (efecto secundario), run/with (cálculo)
inline + reified: lambdas sin coste adicional con información de tipos en tiempo de ejecución

A continuación: cree aplicaciones con varias pantallas mediante Fragments.

Preguntas frecuentes

¿La lección «Funciones de extensión y de orden superior» es gratis?

Sí — el texto completo de «Funciones de extensión y de orden superior» 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 4 lecciones en total.

¿Qué aprenderé en «Funciones de extensión y de orden superior»?

Añada comportamiento a tipos existentes mediante funciones de extensión y utilice funciones de orden superior y funciones de ámbito (let, apply, also, run, with) para escribir código Kotlin expresivo. 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 4 de 4.

¿Cuánto tiempo toma la lección «Funciones de extensión y de orden superior»?

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

Seguridad frente a valores nulos
Clases y objetos
Clases de datos y clases selladas
Funciones de extensión y de orden superior

← Volver a Android Academy