Kotlin Academy · Lección

Indexación e invocación

get, set e invoke

Indexación e invocación es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 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 Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

El operador de índice

Definir operator fun get permite leer mediante la sintaxis de corchetes: obj[i].

class Row(val cells: List<String>) {
    operator fun get(i: Int) = cells[i]
}

fun main() {
    val r = Row(listOf("a", "b", "c"))
    println(r[1])
}

Escritura con set

operator fun set permite realizar asignaciones: obj[i] = value. El último parámetro es el valor.

class Grid {
    private val data = IntArray(3)
    operator fun get(i: Int) = data[i]
    operator fun set(i: Int, value: Int) { data[i] = value }
}

fun main() {
    val g = Grid()
    g[0] = 42
    println(g[0])
}

Indexación con varios argumentos

get y set pueden aceptar varios índices, lo que resulta perfecto para las matrices.

class Matrix {
    private val d = Array(2) { IntArray(2) }
    operator fun get(r: Int, c: Int) = d[r][c]
    operator fun set(r: Int, c: Int, v: Int) { d[r][c] = v }
}

fun main() {
    val m = Matrix()
    m[1, 1] = 9
    println(m[1, 1])
}

Índices con claves que no son Int

Los parámetros de índice pueden ser de cualquier tipo, lo que permite un acceso similar al de los mapas.

class Settings {
    private val map = mutableMapOf<String, String>()
    operator fun get(key: String) = map[key]
    operator fun set(key: String, value: String) { map[key] = value }
}

fun main() {
    val s = Settings()
    s["theme"] = "dark"
    println(s["theme"])
}

El operador invoke

Definir operator fun invoke permite llamar a una instancia como si fuera una función: obj().

class Greeter(val name: String) {
    operator fun invoke() = "Hello, $name"
}

fun main() {
    val g = Greeter("Sam")
    println(g())
}

Invoke con argumentos

invoke puede aceptar parámetros, haciendo que el objeto se comporte como una función parametrizada.

class Multiplier(val factor: Int) {
    operator fun invoke(x: Int) = x * factor
}

fun main() {
    val triple = Multiplier(3)
    println(triple(5))
}

Objetos invocables con estado

Como el objeto conserva el estado, invoke puede crear objetos configurables con forma de función.

class Accumulator {
    var total = 0
    operator fun invoke(n: Int) { total += n }
}

fun main() {
    val acc = Accumulator()
    acc(5)
    acc(10)
    println(acc.total)
}

Varias sobrecargas de invoke

Puede declarar varias sobrecargas de invoke con parámetros diferentes.

class Printer {
    operator fun invoke(s: String) = println(s)
    operator fun invoke(n: Int) = println("num: $n")
}

fun main() {
    val p = Printer()
    p("hi")
    p(7)
}

Índices en expresiones

El acceso mediante índices se combina de forma natural con otras operaciones.

class Scores(private val list: List<Int>) {
    operator fun get(i: Int) = list[i]
}

fun main() {
    val s = Scores(listOf(10, 20, 30))
    println(s[0] + s[2])
}

Combinar get e invoke

Un tipo puede admitir tanto la indexación como la llamada para ofrecer una API expresiva.

class Lookup(private val data: Map<String, Int>) {
    operator fun get(key: String) = data[key]
    operator fun invoke() = data.size
}

fun main() {
    val l = Lookup(mapOf("a" to 1))
    println(l["a"])
    println(l())
}

Cómo lo usa la biblioteca estándar

Las operaciones de List list[i] y de Map map[key] son exactamente estos operadores. Sus tipos también pueden resultar igual de naturales.

fun main() {
    val list = listOf(1, 2, 3)
    val map = mapOf("x" to 9)
    println(list[0])
    println(map["x"])
}

Comprobación rápida

Compruebe su comprensión de los índices y de invoke.

Resumen

Ha aprendido sobre índices e invoke:

get implementa obj[i]; set implementa obj[i] = v.
Los operadores de índice admiten varias claves y claves que no sean de tipo Int.
invoke permite llamar a las instancias como si fueran funciones, con argumentos o sin ellos.
Las colecciones estándar utilizan exactamente estos operadores.

class Box {
    private val m = mutableMapOf<String, Int>()
    operator fun get(k: String) = m[k]
    operator fun set(k: String, v: Int) { m[k] = v }
}

fun main() {
    val b = Box()
    b["x"] = 5
    println(b["x"])
}

Preguntas frecuentes

¿La lección «Indexación e invocación» es gratis?

Sí — el texto completo de «Indexación e invocación» 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 Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Indexación e invocación»?

get, set e invoke Practicas Kotlin 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 Kotlin Academy?

No se requiere experiencia previa. Kotlin 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 3 de 4.

¿Cuánto tiempo toma la lección «Indexación e invocación»?

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 Kotlin Academy?

Sí. Cada lección de Kotlin 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 Kotlin Academy