Partial Function ist ein mathematisches Konzept. Es handelt sich nicht um eine Art „Funktion“, sondern um ein paralleles Konzept zu Funktionen.
Partia Function in Scala ist ein Trait vom Typ PartialFunction[A,B], das einen Parameter vom Typ A empfängt und ein Ergebnis vom Typ B zurückgibt.
Zum Beispiel:
val pf: PartialFunction[Int, String] = { case 1 => "One" case 2 => "Two" case 3 => "Three" case _ => "Other" } println(pf(1)) //One println(pf(2)) //Two println(pf(3)) //Three println(pf(4)) //Other
Es gibt einige Methoden innerhalb der Teilfunktion, wie z. B. isDefinedAt, OrElse, andThen, applyOrElse usw.
isDefinedAt: Die Funktion dieser Funktion besteht darin, zu bestimmen, ob die eingehenden Parameter innerhalb des von dieser Teilfunktion verarbeiteten Bereichs liegen.
Versuchen Sie, isDefinedAt() mit dem soeben definierten pf zu verwenden. Solange es sich bei der Zahl um eine Zahl handelt, ist sie korrekt, da es die Groß-/Kleinschreibung _=>"Other" gibt. Wenn Sie ihn in einen anderen Typ ändern, wird ein Fehler gemeldet.
val pf: PartialFunction[Int, String] = { case 1 => "One" case 2 => "Two" case 3 => "Three" case _ => "Other" } println(pf.isDefinedAt(1)) //true println(pf.isDefinedAt(2)) //true println(pf.isDefinedAt(3)) //true println(pf.isDefinedAt(4)) //true println(pf.isDefinedAt("1")) /** * 类型不匹配 * type mismatch; * found : String("1") * required: Int * println(pf.isDefinedAt("1")) */
orElse: Verwenden Sie mehrere Teilfunktionen in Kombination. Der Effekt ähnelt einer case-Anweisung.
val onePF: PartialFunction[Int, String] = { case 1 => "One" } val twoPF: PartialFunction[Int, String] = { case 2 => "Two" } val threePF: PartialFunction[Int, String] = { case 3 => "Three" } val otherPF: PartialFunction[Int, String] = { case _ => "Other" } val newPF = onePF orElse twoPF orElse threePF orElse otherPF println(newPF(1)) //One println(newPF(2)) //Two println(newPF(3)) //Three println(newPF(4)) //Other
Auf diese Weise hat der neue PF die gleiche Wirkung wie der ursprüngliche PF.
andThen: entspricht kontinuierlichen Aufrufen von Methoden wie g(f(x)).
Der Ergebnisrückgabetyp von pf1 muss mit dem Parametereingabetyp von pf2 übereinstimmen, andernfalls wird ein Fehler gemeldet.
val pf1: PartialFunction[Int, String] = { case i if i == 1 => "One" } val pf2: PartialFunction[String, String] = { case str if str eq "One" => "The num is 1" } val num = pf1 andThen pf2 println(num(1)) //The num is 1
applyOrElse: Es empfängt 2 Parameter, der erste ist der aufrufende Parameter und der zweite ist eine Rückruffunktion. Stimmen die Parameter des ersten Aufrufs überein, wird der passende Wert zurückgegeben, andernfalls wird die Callback-Funktion aufgerufen.
val pf: PartialFunction[Int, String] = { case 1 => "One" } println(pf.applyOrElse(1, { num: Int => "two" })) //One println(pf.applyOrElse(2, { num: Int => "two" })) //two
Partial Applied Function wird auch Partial Applied Function genannt. Dem englischen Namen nach zu urteilen, gibt es nur einen Wortunterschied zwischen Partial Function und Partial Function, aber es gibt einen himmelweiten Unterschied zwischen ihnen .
Teilanwendungsfunktion bedeutet, dass eine Funktion n Parameter hat. Wenn wir ihr weniger als n Parameter zur Verfügung stellen, erhalten wir eine Teilanwendungsfunktion.
Definieren Sie beispielsweise eine Funktion mit 3 Parametern und stellen Sie dann mehrere Teilanwendungsfunktionen mit 1-2 bekannten Parametern bereit
def add(x: Int, y: Int, z: Int) = x + y + z // x 已知 def addX = add(1, _: Int, _: Int) println(addX(2, 3)) //6 println(addX(3, 4)) //8 // x 和 y 已知 def addXAndY = add(10, 100, _: Int) println(addXAndY(1)) //111 // z 已知 def addZ = add(_: Int, _: Int, 10) println(addZ(1, 2)) //13
Das obige ist der detaillierte Inhalt vonVerwendung von Teilfunktionen und Teilanwendungsfunktionen in Java und Scala. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!