Extensiones con alcance y extensiones de companion
Limite la visibilidad de las extensiones y añada extensiones a objetos companion.
Extensiones con alcance y extensiones de companion 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.
¿Por qué limitar el ámbito de las extensiones?
De forma predeterminada, las extensiones son visibles en cualquier lugar donde se importen. Limitar su ámbito a una clase, un archivo o un contexto reduce la contaminación del espacio de nombres y mejora su descubribilidad.
Extensiones privadas de archivo
Marque una función de extensión como private a nivel de archivo para limitarla exclusivamente a ese archivo.
private fun String.shout() = uppercase() + "!"
fun main() {
println("hello".shout()) // HELLO!
}Visibilidad internal
Utilice internal para limitar las extensiones al módulo actual; es perfecto para elementos internos de una biblioteca que no están destinados a uso externo.
internal fun List<Int>.sumIfPositive(): Int = filter { it > 0 }.sum()
fun main() {
println(listOf(-1, 2, 3, -4).sumIfPositive()) // 5
}Funciones de extensión miembro
Declare una extensión dentro de una clase para que solo pueda utilizarse cuando una instancia de esa clase esté en el ámbito. Tiene dos receptores: el de despacho (la clase) y el de extensión (el objetivo).
class StringHelper(val prefix: String) {
fun String.withPrefix() = prefix + this
fun build(): String = "world".withPrefix() // calls extension via instance
}
fun main() {
println(StringHelper("hello ").build()) // hello world
}Visibilidad de las extensiones miembro
Las extensiones miembro no son accesibles desde fuera de la clase de despacho. Son útiles para la encapsulación.
class Repo {
fun List<Int>.allPositive() = all { it > 0 }
fun check(xs: List<Int>) = xs.allPositive()
}
fun main() {
val r = Repo()
println(r.check(listOf(1, 2, 3))) // true
// listOf(1).allPositive() // ERROR — no access
}Extensión sobre un companion object
Añada una extensión al companion object de una clase. Para quienes la invocan parece un método estático, pero vive fuera de la clase.
class Greeter {
companion object
}
fun Greeter.Companion.morning() = "Good morning!"
fun main() {
println(Greeter.morning())
}¿Por qué utilizar extensiones de companion?
Son útiles para añadir métodos de fábrica o auxiliares desde fuera de la clase original, sin modificarla.
class User(val name: String) {
companion object
}
fun User.Companion.guest() = User("Guest")
fun User.Companion.system() = User("System")
fun main() {
println(User.guest().name)
println(User.system().name)
}Se requiere un companion vacío
La clase debe declarar un companion object (aunque esté vacío) para que se le puedan asociar extensiones de companion. De lo contrario, el objetivo de la extensión no existe.
class Box {
companion object // required, even if empty
}
fun Box.Companion.create(): Box = Box()
fun main() {
println(Box.create())
}Extensiones con ámbito mediante imports
Puede limitar el uso de una extensión importándola solo en archivos específicos. Los archivos que no la importen no podrán verla.
// File A:
// fun String.shout() = uppercase()
// File B imports:
// import com.example.shout
// Only File B can call shout()
fun String.shout() = uppercase() + "!"
fun main() { println("hi".shout()) }Función de extensión mediante una función de ámbito
Utilice with o apply para introducir temporalmente un objeto en el ámbito y utilizarlo con una extensión.
class StringTools {
fun String.greet() = "Hello, $this!"
fun process(name: String) = with(this) {
name.greet()
}
}
fun main() {
println(StringTools().process("Ada"))
}Propiedades de extensión en Companion
Las extensiones de Companion también pueden ser propiedades: añada constantes con nombre desde fuera de la clase.
class HttpStatus {
companion object
}
val HttpStatus.Companion.OK_CODE: Int get() = 200
val HttpStatus.Companion.NOT_FOUND: Int get() = 404
fun main() {
println(HttpStatus.OK_CODE)
println(HttpStatus.NOT_FOUND)
}Prácticas recomendadas
Utilice private para ayudantes locales al archivo, internal para API exclusivas del módulo, extensiones miembro para encapsulación y extensiones de Companion para añadir ayudantes similares a fábricas desde fuera.
class StringUtils {
companion object
}
fun StringUtils.Companion.isAlpha(s: String) = s.all { it.isLetter() }
fun main() {
println(StringUtils.isAlpha("hello"))
println(StringUtils.isAlpha("hi5"))
}Comprobación rápida
¿Qué se requiere en una clase para poder añadirle una extensión de Companion desde fuera?
Resumen
Limite el ámbito de las extensiones con private, internal o como extensiones miembro dentro de una clase. Añada extensiones de Companion (funciones o propiedades) desde fuera asociándolas al objeto companion declarado de la clase. Esto reduce la contaminación del espacio de nombres y mantiene el código modular.
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 «Extensiones con alcance y extensiones de companion» es gratis?
Sí — el texto completo de «Extensiones con alcance y extensiones de companion» 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 «Extensiones con alcance y extensiones de companion»?
Limite la visibilidad de las extensiones y añada extensiones a objetos companion. 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 «Extensiones con alcance y extensiones de companion»?
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 de extensión: sintaxis y reglas de despacho
- Propiedades de extensión y extensiones calculadas
- Extensiones con alcance y extensiones de companion
- Extensiones prácticas: auxiliares para Context, View y String