Scala for Backend Engineering & Functional Programming · Lektion

Extension Methods

Typen um Methoden erweitern

Extension Methods ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Methoden zu vorhandenen Typen hinzufügen

Extension-Methoden ermöglichen es Ihnen, einem Typ, den Sie nicht selbst definiert haben, etwa Int oder String, neue Methoden hinzuzufügen, ohne dessen Quellcode zu ändern. Scala 3 bietet dafür eine übersichtliche Syntax.

object Main:
  extension (x: Int)
    def squared: Int = x * x
  def main(args: Array[String]): Unit =
    println(5.squared)

Die Extension-Syntax

Schreiben Sie extension (param: Type), gefolgt von einer oder mehreren Methodendefinitionen. Innerhalb jeder Methode verweist der Parameter auf den Empfängerwert.

object Main:
  extension (s: String)
    def shout: String = s.toUpperCase + "!"
  def main(args: Array[String]): Unit =
    println("hello".shout)

Mehrere Methoden in einem Block

Eine einzelne extension-Klausel kann mehrere Methoden definieren, die alle auf demselben Empfängertyp arbeiten.

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)

Extension-Methoden mit Parametern

Extension-Methoden können zusätzlich zum Empfänger eigene Parameter entgegennehmen.

object Main:
  extension (x: Int)
    def times(s: String): String = s * x
  def main(args: Array[String]): Unit =
    println(3.times("ab"))

Generische Extension-Methoden

Extensions können generisch sein und Methoden zu einer ganzen Gruppe von Typen wie List[A] hinzufügen.

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)

Warum Extensions impliziten Konvertierungen überlegen sind

Extension-Methoden erreichen das frühere Ziel des „pimp my library“ auf sicherere Weise: Sie fügen nur die benannten Methoden hinzu, ohne dass an anderer Stelle das Risiko stiller Typkonvertierungen besteht.

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))

Extensions und Typeclasses

Extension-Methoden lassen sich hervorragend mit Typeclasses kombinieren: Definieren Sie das Verhalten über eine given-Instanz und stellen Sie es mithilfe von using als Methode bereit.

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)

Operatoren definieren

Da Operatoren lediglich Methoden sind, können Extensions auch symbolische Operatoren zu vorhandenen Typen hinzufügen.

object Main:
  extension (x: Int)
    def **(exp: Int): Int = math.pow(x, exp).toInt
  def main(args: Array[String]): Unit =
    println(2 ** 10)

Gültigkeitsbereiche und Imports

Extension-Methoden sind nur dort verfügbar, wo sie im Gültigkeitsbereich liegen. Definieren Sie sie in einem Objekt und importieren Sie dieses, um sie zu verwenden. So bleibt ihr Gültigkeitsbereich kontrolliert.

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)

Extension-Methoden verketten

Extension-Methoden geben gewöhnliche Werte zurück. Daher können Sie sie mit integrierten Methoden verketten und so flüssig lesbare Pipelines bilden.

object Main:
  extension (s: String)
    def emphasize: String = s"*$s*"
  def main(args: Array[String]): Unit =
    println("scala".toUpperCase.emphasize)

Ein praktischer Helfer

Extension-Methoden eignen sich ideal für kleine domänenspezifische Helfer, durch die aufrufender Code natürlich lesbar wird.

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)

Kurze Überprüfung

Was ist der wichtigste Vorteil von Scala-3-Extension-Methoden gegenüber impliziten Konvertierungen, wenn Sie Methoden hinzufügen möchten?

Zusammenfassung

Sie haben Extension-Methoden kennengelernt:

extension (x: Type) def ... fügt vorhandenen Typen Methoden hinzu
Ein Block kann mehrere Methoden einschließlich Operatoren definieren
Sie können generisch sein und Parameter entgegennehmen
Über using lassen sie sich natürlich mit Typeclasses kombinieren
Sie sind sicherer als implizite Konvertierungen und müssen in den Gültigkeitsbereich importiert werden

Häufig gestellte Fragen

Ist die Lektion „Extension Methods“ kostenlos?

Ja — der vollständige Text von „Extension Methods“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Extension Methods“?

Typen um Methoden erweitern Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Extension Methods“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming