Scala 理解'；案例'；部分函数中的关键字

我是Scala的新手，我正在尝试解码它的结构，我了解了它的语法，它类似于Java switch语句

val x: Int = Random.nextInt(10)

x match {
  case 0 => "zero"
  case 1 => "one"
  case 2 => "two"
  case _ => "other"
}

这里的代码非常明显且可读。我遇到了非常明显和清楚的问题，它们是什么

部分函数是一个不提供答案的函数 每个可能的输入值都可以给出

我感到困惑的是在部分函数体中使用

case

像这样：

val divide2: PartialFunction[Int, Int] = {
    case d: Int if d != 0 => 42 / d // WHAT IS THIS ?! 
}

如果没有

match

语句，我不明白

case

是如何使用的，Scala是如何解释的，它是如何读取的，它是一个方法、一个类还是另一个构造？如果没有

match

语句，我还能用什么方法使用

case

val x: Int = Random.nextInt(10)

x match {
  case 0 => "zero"
  case 1 => "one"
  case 2 => "two"
  case _ => "other"
}

编辑：

我试图摆弄这个案子，但还是不明白。比如说

val SomeFun: PartialFunction[Int, Int] = {
    case d: Int if d != 0 => 1000 / d
    case f: Int if f != 2 => 100 / f
    case m: Int if m != 1 => 10 / m
  }

这是怎么回事

尝试此操作会产生错误

val SomeFun = {
    case d: Int if d != 0 => 1000 / d
    case f: Int if f != 2 => 100 / f
    case m: Int if m != 1 => 10 / m
  }


Error:(29, 17) missing parameter type for expanded function
The argument types of an anonymous function must be fully known. (SLS 8.5)
Expected type was: ?

---

不匹配的case是否在分部函数之外的任何地方使用

这意味着只有当输入参数与大小写表达式匹配时，才会应用分部函数

实际生成的类如下所示：

val divide = new PartialFunction[Int, Int] {
    def apply(x: Int) = 42 / x
    def isDefinedAt(x: Int) = x != 0
}

使用orElse，您可以应用或处理多个定义：

funcForInt orElse funcForDouble orElse funcForString

好作文

编辑：

上面使用的是匿名类特性。如果删除变量的类型，只需给它一个块表达式，其中包含一些编译器无法真正使用的case表达式

---

参考：

我将尝试回答这个问题：

我不明白在没有匹配语句的情况下case是如何使用的，它是如何使用的 这是由Scala解释的，它是如何读取的，它是一个方法还是一个类 还是另一种构造

主要是指我将引用和解释的文章

这一做法奏效的原因是：

val f: (Any) => String = {
    case i: Int => "Int"
    case d: Double => "Double"
    case _ => "Other"
}

编译器将其解释为匿名函数

当您创建val函数时，像这样的代码真正要做的就是为匿名函数指定一个变量名

为了支持第一条语句，Scala编程第15.7节规定：

大括号中的一系列大小写可以在任何可以使用函数文字的地方使用

因此，它与在

filter

或

collect

中使用相同的语法没有什么不同

上述代码实质上创建了一个

Function1

对象。正如所解释的那样：

PartialFunction和scala.Function1之间的主要区别是 PartialFunction的用户可以选择执行某些操作 与声明在其域之外的输入不同

---

它是一个模式匹配匿名函数，如中所述

尝试此操作会产生错误

val SomeFun = ...

这是因为参数类型需要知道，就像“普通”匿名函数一样

x=>…

。不同之处在于，在模式匹配匿名函数中，没有地方直接指定参数类型（相当于

（x:Int）=>…

），因此必须有一个预期的类型，例如

val-SomeFun:PartialFunction[Int，Int]

或

val-SomeFun:Int=>Int

val SomeFun: PartialFunction[Int, Int] = {
    case d: Int if d != 0 => 1000 / d
    case f: Int if f != 2 => 100 / f
    case m: Int if m != 1 => 10 / m
  }

被翻译成

val SomeFun: PartialFunction[Int, Int] = new PartialFunction[Int, Int] {
  override def apply(x: Int) = x match {
    case d: Int if d != 0 => 1000 / d
    case f: Int if f != 2 => 100 / f
    case m: Int if m != 1 => 10 / m
  }
  override def isDefined(x: Int) = x match {
    case d: Int if d != 0 => true
    case f: Int if f != 2 => true
    case m: Int if m != 1 => true
    case _ => false
  }
}

---

我理解它是如何工作的，但我不理解应用或使用case的语法，以及这个case如何转换为使用apply，是如何定义的，等等。。。