Comment utiliser les fonctions partielles et les fonctions appliquées partielles en Java et Scala

Fonction Partielle

La fonction Partielle est un concept mathématique. Ce n'est pas un type de « fonction ». C'est un concept parallèle aux fonctions.

La fonction Partia dans Scala est un trait dont le type est PartialFunction[A,B], qui reçoit un paramètre de type A et renvoie un résultat de type B.

Par exemple :

    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

Il existe certaines méthodes à l'intérieur de la fonction partielle, telles que isDefinedAt, OrElse et Then, applyOrElse, etc.

isDefinedAt

isDefinedAt : La fonction de cette fonction est de déterminer si les paramètres entrants sont dans la plage traitée par cette fonction partielle.

Essayez d'utiliser isDefinedAt() pour le pf que vous venez de définir. Tant que le nombre est un nombre, il est correct car il y a le cas _=>"Autre". Si vous le remplacez par un autre type, une erreur sera signalée.

    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 : utilisez plusieurs fonctions partielles en combinaison, l'effet est similaire à une instruction case.

    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

De cette façon, le nouveau PF a le même effet que le PF original.

andThen

andThen : équivalent aux appels continus de méthodes, telles que g(f(x)).

Le type de retour du résultat de pf1 doit être cohérent avec le type d'entrée du paramètre de pf2, sinon une erreur sera signalée.

   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 : Il reçoit 2 paramètres, le premier est le paramètre appelant et le second est une fonction de rappel. Si les paramètres du premier appel correspondent, la valeur correspondante est renvoyée, sinon la fonction de rappel est appelée.

  val pf: PartialFunction[Int, String] = {
      case 1 => "One"
    }
    println(pf.applyOrElse(1, { num: Int => "two" }))  //One
    println(pf.applyOrElse(2, { num: Int => "two" }))  //two

Fonction partielle appliquée

La fonction partielle appliquée est également appelée fonction partielle appliquée. À en juger par le nom anglais, il n'y a qu'un seul mot de différence entre la fonction partielle et la fonction partielle, mais il y a un monde de différence entre elles. .

La fonction d'application partielle signifie qu'une fonction a n paramètres, et si nous lui fournissons moins de n paramètres, nous obtenons une fonction d'application partielle.

Par exemple, définissez une fonction avec 3 paramètres, puis fournissez plusieurs fonctions d'application partielle avec 1 à 2 paramètres connus

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!