Borrado de tipos y parámetros de tipo reified
Use reified con funciones inline para acceder a la información de tipos en tiempo de ejecución.
Borrado de tipos y parámetros de tipo reified es una lección gratuita de Kotlin 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 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.
¿Qué es el borrado de tipos?
En tiempo de ejecución, la JVM borra los argumentos de tipo genéricos. List<String> y List<Int> son simplemente List. Esto limita las operaciones de tipos en tiempo de ejecución sobre genéricos.
fun main() {
val strings: List<String> = listOf("a", "b")
val ints: List<Int> = listOf(1, 2)
println(strings.javaClass == ints.javaClass) // true: both ArrayList
println(strings is List<*>) // OK with star
// println(strings is List<String>) // warning: unchecked cast
}El problema: no se pueden comprobar los tipos borrados
No puede usar is con un argumento de tipo genérico específico porque la información del tipo desaparece en tiempo de ejecución.
fun checkType(obj: Any) {
// This works:
if (obj is List<*>) println("It's a list of something")
// This doesn't compile cleanly:
// if (obj is List<String>) println("It's a list of strings") // unchecked
}
fun main() {
checkType(listOf("hello"))
checkType(42)
}Resumen de las funciones inline
inline copia el cuerpo de la función en el sitio de llamada durante la compilación. Esto es lo que permite usar reified: el argumento de tipo también se sustituye en el sitio de llamada.
inline fun <T> myRun(block: () -> T): T = block()
fun main() {
val result = myRun { 42 }
println(result) // 42
// The compiler inlines the lambda body — no object allocation
}reified: acceso a T en tiempo de ejecución
Combinar inline con reified conserva el argumento de tipo en el sitio de llamada, lo que permite usar is, as y ::class sobre T.
inline fun <reified T> isInstance(value: Any): Boolean = value is T
fun main() {
println(isInstance<String>("hello")) // true
println(isInstance<Int>("hello")) // false
println(isInstance<List<*>>(listOf())) // true
}Obtención de KClass de T
Con reified T, puede obtener T::class en tiempo de ejecución, algo normalmente imposible en funciones genéricas.
inline fun <reified T> classNameOf(): String = T::class.simpleName ?: "Unknown"
fun main() {
println(classNameOf<String>()) // String
println(classNameOf<Int>()) // Int
println(classNameOf<List<*>>()) // List
}Conversión segura con reified
Use reified para escribir una utilidad de conversión segura con respecto al tipo que devuelva null en lugar de lanzar una excepción.
inline fun <reified T> Any?.safeCast(): T? = this as? T
fun main() {
val obj: Any = "Hello"
val s: String? = obj.safeCast<String>()
val i: Int? = obj.safeCast<Int>()
println(s) // Hello
println(i) // null
}Análisis de JSON con reified
Bibliotecas como Gson o kotlinx.serialization usan reified para inferir el tipo de destino en el sitio de llamada sin pasar explícitamente objetos Class.
import com.google.gson.Gson
// Simulated without real Gson:
inline fun <reified T> parseJson(json: String): T {
return Gson().fromJson(json, T::class.java)
}
// Usage:
// val user: User = parseJson<User>("""{"name":"Alice"}""")reified con filterIsInstance
La función filterIsInstance<T>() de la biblioteca estándar usa reified para filtrar una lista y conservar un tipo específico sin conversiones manuales.
fun main() {
val mixed: List<Any> = listOf(1, "hello", 2.5, "world", true)
val strings = mixed.filterIsInstance<String>()
val ints = mixed.filterIsInstance<Int>()
println(strings) // [hello, world]
println(ints) // [1]
}No se puede usar reified en funciones no inline
reified solo funciona con funciones inline. Intentar usarlo sin inline provoca un error de compilación.
// Error:
// fun <reified T> broken(): String = T::class.simpleName ?: "?"
// Must be inline:
inline fun <reified T> correct(): String = T::class.simpleName ?: "?"
fun main() {
println(correct<Double>()) // Double
}reified y reflexión
Combine reified con reflexión para inspeccionar dinámicamente las propiedades o anotaciones de un tipo sin los parámetros Class repetitivos.
inline fun <reified T : Any> properties(): List<String> =
T::class.members.map { it.name }
data class Point(val x: Int, val y: Int)
fun main() {
println(properties<Point>()) // [x, y, component1, component2, copy, equals, hashCode, toString]
}Práctica: localizador de servicios seguro con respecto a los tipos
Use reified para crear un localizador de servicios que asigne KClass a instancias, con el fin de implementar una DI ligera sin procesadores de anotaciones.
val registry = mutableMapOf<kotlin.reflect.KClass<*>, Any>()
inline fun <reified T : Any> register(instance: T) { registry[T::class] = instance }
@Suppress("UNCHECKED_CAST")
inline fun <reified T : Any> resolve(): T = registry[T::class] as T
class Logger { fun log(msg: String) = println("[LOG] $msg") }
fun main() {
register(Logger())
resolve<Logger>().log("Service located!")
}Limitaciones de reified
Los parámetros de tipo reified no pueden utilizarse en contextos no inline, no pueden almacenar el tipo para usarlo más adelante ni pueden pasarse a funciones no inline que necesiten el tipo en tiempo de ejecución.
inline fun <reified T> foo() {
val clazz = T::class // OK here
// bar(clazz) // must pass clazz explicitly to non-inline funs
println(clazz.simpleName)
}
fun bar(clazz: kotlin.reflect.KClass<*>) = println(clazz.simpleName)
fun main() { foo<String>() }Comprobación rápida
¿Qué se necesita para que un parámetro de tipo sea reified?
Resumen
El borrado de tipos elimina la información de tipos genéricos en tiempo de ejecución. reified en funciones inline conserva el argumento de tipo en el sitio de llamada, lo que permite usar is, as, ::class y la reflexión sobre T sin pasar objetos Class manualmente.
Aprende Kotlin con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 51
- Lecciones
- 203
Preguntas frecuentes
¿La lección «Borrado de tipos y parámetros de tipo reified» es gratis?
Sí — el texto completo de «Borrado de tipos y parámetros de tipo reified» 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 «Borrado de tipos y parámetros de tipo reified»?
Use reified con funciones inline para acceder a la información de tipos en tiempo de ejecución. 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 4 de 4.
¿Cuánto tiempo toma la lección «Borrado de tipos y parámetros de tipo reified»?
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
- Funciones genéricas y restricciones de tipos con where
- Varianza en el sitio de declaración: in y out
- Proyección estrella y cuándo usar *
- Borrado de tipos y parámetros de tipo reified