Verwendung von Teilfunktionen und Teilanwendungsfunktionen in Java und Scala

Partial Function

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

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

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

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

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

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!