Métodos de extensión
Añada métodos a tipos
Métodos de extensión es una lección gratuita de Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
Añadir métodos a tipos existentes
Los métodos de extensión permiten añadir métodos nuevos a un tipo que no es de su propiedad, como Int o String, sin modificar su código fuente. Scala 3 ofrece una sintaxis clara para ello.
object Main:
extension (x: Int)
def squared: Int = x * x
def main(args: Array[String]): Unit =
println(5.squared)La sintaxis de extensión
Escriba extension (param: Type) seguido de una o más definiciones de métodos. Dentro de cada método, el parámetro hace referencia al valor receptor.
object Main:
extension (s: String)
def shout: String = s.toUpperCase + "!"
def main(args: Array[String]): Unit =
println("hello".shout)Varios métodos en un bloque
Una sola cláusula extension puede definir varios métodos que operen sobre el mismo tipo receptor.
object Main:
extension (x: Int)
def squared: Int = x * x
def cubed: Int = x * x * x
def isEven: Boolean = x % 2 == 0
def main(args: Array[String]): Unit =
println(4.squared)
println(3.cubed)
println(6.isEven)Métodos de extensión con parámetros
Los métodos de extensión pueden recibir sus propios parámetros, además del receptor.
object Main:
extension (x: Int)
def times(s: String): String = s * x
def main(args: Array[String]): Unit =
println(3.times("ab"))Métodos de extensión genéricos
Las extensiones pueden ser genéricas y añadir métodos a toda una familia de tipos, como List[A].
object Main:
extension [A](xs: List[A])
def second: A = xs(1)
def main(args: Array[String]): Unit =
println(List(10, 20, 30).second)
println(List("a", "b").second)Por qué las extensiones son mejores que las conversiones implícitas
Los métodos de extensión alcanzan el antiguo objetivo de «pimp-my-library» de forma más segura: solo añaden los métodos indicados, sin riesgo de conversiones de tipo silenciosas en otras partes.
object Main:
extension (d: Double)
def percentOf(total: Double): Double = d / total * 100
def main(args: Array[String]): Unit =
println(25.0.percentOf(200.0))Extensiones y clases de tipos
Los métodos de extensión combinan muy bien con las clases de tipos: defina el comportamiento mediante una instancia given y expóngalo como método usando using.
trait Show[A]:
def show(a: A): String
object Main:
given Show[Int] with
def show(a: Int): String = s"<$a>"
extension [A](a: A)
def display(using s: Show[A]): String = s.show(a)
def main(args: Array[String]): Unit =
println(42.display)Definir operadores
Como los operadores no son más que métodos, las extensiones también pueden añadir operadores simbólicos a tipos existentes.
object Main:
extension (x: Int)
def **(exp: Int): Int = math.pow(x, exp).toInt
def main(args: Array[String]): Unit =
println(2 ** 10)Ámbito e importaciones
Los métodos de extensión solo están disponibles donde se encuentran en el ámbito. Defínalos en un objeto e impórtelo para usarlos, manteniendo controlado su alcance.
object StringOps:
extension (s: String)
def reversedWords: String = s.split(" ").reverse.mkString(" ")
object Main:
import StringOps._
def main(args: Array[String]): Unit =
println("hello there world".reversedWords)Encadenar métodos de extensión
Los métodos de extensión devuelven valores normales, por lo que puede encadenarlos con métodos integrados para formar pipelines fluidos.
object Main:
extension (s: String)
def emphasize: String = s"*$s*"
def main(args: Array[String]): Unit =
println("scala".toUpperCase.emphasize)Un helper práctico
Los métodos de extensión son perfectos para pequeños helpers del dominio que hacen que el código que los invoca se lea de forma natural.
object Main:
extension (n: Int)
def isPrime: Boolean =
n > 1 && (2 until n).forall(d => n % d != 0)
def main(args: Array[String]): Unit =
println((2 to 12).filter(_.isPrime).toList)Comprobación rápida
¿Cuál es la principal ventaja de los métodos de extensión de Scala 3 frente a las conversiones implícitas para añadir métodos?
Repaso
Ha aprendido sobre los métodos de extensión:
extension (x: Type) def ...añade métodos a tipos existentes- Un bloque puede definir varios métodos, incluidos operadores
- Pueden ser genéricos y recibir parámetros
- Se combinan naturalmente con las clases de tipos mediante
using - Son más seguros que las conversiones implícitas y deben importarse al ámbito
Preguntas frecuentes
¿La lección «Métodos de extensión» es gratis?
Sí — el texto completo de «Métodos de extensió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 Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué aprenderé en «Métodos de extensión»?
Añada métodos a tipos Practicas Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming 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 «Métodos de extensió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 Scala for Backend Engineering & Functional Programming?
Sí. Cada lección de Scala for Backend Engineering & Functional Programming 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
- Parámetros implícitos
- given/using de Scala 3
- Conversiones implícitas
- Métodos de extensión