Scala for Backend Engineering & Functional Programming · Lektion

Gängige Typeclasses

Show, Ordering, Numeric

Gängige Typeclasses ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Standardtypklassen

Die Standardbibliothek von Scala enthält mehrere Typklassen, die Sie täglich verwenden, manchmal ohne es zu bemerken:

Ordering[A] — legt fest, wie Werte verglichen werden.
Numeric[A] — ermöglicht arithmetische Operationen mit Zahlen.
Darstellung im Stil von Show (benutzerdefiniert oder Cats' Show).

Ordering ermöglicht sorted

List.sorted benötigt ein implizites Ordering[A]. Die Standardbibliothek stellt Instanzen für Zahlen, Zeichenketten und weitere Typen bereit.

@main def run(): Unit = {
  println(List(3, 1, 2).sorted)
  println(List("pear", "apple", "fig").sorted)
}

Benutzerdefiniertes Ordering

Übergeben Sie ein explizites Ordering, um anders zu sortieren, beispielsweise absteigend oder anhand eines abgeleiteten Schlüssels.

@main def run(): Unit = {
  val nums = List(3, 1, 2)
  println(nums.sorted(Ordering.Int.reverse))
  val words = List("bbb", "a", "cc")
  println(words.sortBy(_.length))
}

Ordering für Case-Klassen

Stellen Sie eine Ordering-Instanz für Ihren eigenen Typ bereit, damit Sammlungen dieses Typs sortiert werden können. Ordering.by leitet eine Instanz aus einem Schlüssel ab.

case class Person(name: String, age: Int)

object Main {
  implicit val byAge: Ordering[Person] = Ordering.by(_.age)

  def main(args: Array[String]): Unit = {
    val people = List(Person("A", 30), Person("B", 20))
    println(people.sorted)
  }
}

Numeric abstrahiert Arithmetik

Numeric[A] ermöglicht Funktionen, die mit jedem Zahlentyp funktionieren. sum für eine Liste verwendet diese Typklasse.

@main def run(): Unit = {
  println(List(1, 2, 3).sum)
  println(List(1.5, 2.5).sum)
}

Generischen numerischen Code schreiben

Mit einem Context Bound [A: Numeric] können Sie generisch jeden Zahlentyp addieren oder multiplizieren. Verwenden Sie dazu die Operationen der Instanz über Numeric[A].

object Main {
  def addAll[A: Numeric](xs: List[A]): A = {
    val num = implicitly[Numeric[A]]
    xs.foldLeft(num.zero)(num.plus)
  }

  def main(args: Array[String]): Unit = {
    println(addAll(List(1, 2, 3)))
    println(addAll(List(1.0, 2.0, 3.5)))
  }
}

Numerische Operatoren

Wenn Sie die Implicits der Instanz importieren, stehen Ihnen die üblichen Operatoren (+, *) für generische numerische Typen zur Verfügung, sodass der Code natürlich lesbar bleibt.

object Main {
  def square[A](a: A)(implicit num: Numeric[A]): A = {
    import num._
    a * a
  }

  def main(args: Array[String]): Unit = {
    println(square(5))
    println(square(2.5))
  }
}

Eine Show-Typklasse

Show stellt Werte typsicher als Text dar (anders als toString, das für alles existiert). Cats stellt diese Typklasse bereit; hier sehen Sie eine minimale Version.

trait Show[A] { def show(a: A): String }

object Show {
  implicit val intShow: Show[Int] = n => s"Int($n)"
  def apply[A](implicit s: Show[A]): Show[A] = s
}

object Main {
  def main(args: Array[String]): Unit = {
    println(Show[Int].show(42))
  }
}

Ordering sowie max und min

Methoden wie max, min und maxBy für Sammlungen verwenden intern alle Ordering.

@main def run(): Unit = {
  val xs = List(4, 9, 1, 7)
  println(xs.max)
  println(xs.min)
  println(List("a", "abc", "ab").maxBy(_.length))
}

Orderings kombinieren

Sie können mit Ordering.by für ein Tupel zusammengesetzte Orderings erstellen und zuerst nach einem Feld und anschließend nach einem weiteren sortieren.

case class Rec(group: String, score: Int)

object Main {
  implicit val ord: Ordering[Rec] = Ordering.by(r => (r.group, -r.score))

  def main(args: Array[String]): Unit = {
    val data = List(Rec("b", 5), Rec("a", 1), Rec("a", 9))
    data.sorted.foreach(println)
  }
}

Warum hier Typklassen verwendet werden

Da Vergleiche und Arithmetik durch Typklassen umgesetzt werden, funktionieren dasselbe sorted oder sum für integrierte Typen und Ihre eigenen Typen, sofern Sie einfach eine passende Instanz bereitstellen. Das ist die Verwendung von Ad-hoc-Polymorphie in der Standardbibliothek.

Kurze Überprüfung

Testen Sie Ihr Wissen über Standardtypklassen.

Zusammenfassung

Sie haben gängige Standardtypklassen kennengelernt:

Ordering[A] steuert sorted, max und min; erstellt wird es mit Ordering.by.
Numeric[A] ermöglicht generische Arithmetik und bildet die Grundlage für sum.
Typklassen im Stil von Show stellen Werte typsicher dar.

Häufig gestellte Fragen

Ist die Lektion „Gängige Typeclasses“ kostenlos?

Ja — der vollständige Text von „Gängige Typeclasses“ 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 „Gängige Typeclasses“?

Show, Ordering, Numeric 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 3 von 4.

Wie lange dauert die Lektion „Gängige Typeclasses“?

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