Scala 不使用 case class 的模式匹配

在本文中，我们将介绍如何在 Scala 中进行模式匹配，而不使用 case class。Scala 中的模式匹配是一种非常强大和灵活的机制，它允许我们根据输入的类型和结构来执行不同的操作。通常情况下，我们使用 case class 来对不同的数据结构进行模式匹配。然而，在某些情况下，我们可能希望在没有定义 case class 的情况下进行模式匹配。下面，我们将讨论如何实现这一点。

阅读更多：Scala 教程

什么是模式匹配?

模式匹配是一种在编程语言中根据输入值的类型和结构来执行不同操作的机制。它类似于 switch 语句，在不同的情况下执行不同的代码块。但模式匹配更加灵活和强大，可以匹配更复杂的结构，如嵌套的数据类型。

在 Scala 中，我们通常使用 case class 来定义需要进行模式匹配的数据结构。这些 case class 会自动生成与之相匹配的模式，并可以使用模式匹配表达式进行匹配。例如，我们可以创建一个表示图形的 case class，并根据形状的不同执行不同的操作。

sealed trait Shape
case class Circle(radius: Int) extends Shape 
case class Rectangle(width: Int, height: Int) extends Shape
case class Triangle(side: Int) extends Shape

def getArea(shape: Shape): Double = shape match {
  case Circle(radius) => math.Pi * radius * radius
  case Rectangle(width, height) => width * height
  case Triangle(side) => (math.sqrt(3) / 4) * side * side
}

val circle = Circle(5)
println(getArea(circle)) // 输出：78.53981633974483

在上面的示例中，我们定义了三个 case class：Circle、Rectangle 和 Triangle，分别表示圆形、矩形和三角形。我们使用模式匹配表达式 shape match 来根据不同的形状计算其面积。当输入的形状是 Circle 类型时，将执行 case Circle(radius) => math.Pi * radius * radius 这段代码。

不使用 case class 的模式匹配

然而，在某些情况下，我们可能不想使用 case class，而是使用其他方式进行模式匹配。在 Scala 中，我们可以通过自定义 unapply 方法来实现这一点。unapply 方法是一个用于提取对象的值的方法，它返回一个 Option 类型的值，表示提取是否成功。

sealed trait Shape

object Circle {
  def unapply(shape: Shape): Option[Int] = shape match {
    case circle: Circle => Some(circle.radius)
    case _ => None
  }
}

class Circle(val radius: Int) extends Shape 

val shape: Shape = new Circle(5)
shape match {
  case Circle(radius) => println(s"Circle with radius $radius")
  case _ => println("Unknown shape")
}

在上面的示例中，我们定义了一个不使用 case class 的圆形类 Circle，并在伴生对象 Circle 中自定义了 unapply 方法。unapply 方法匹配输入的 shape 是否为 Circle 类型，并返回圆形的半径。在模式匹配表达式中，我们可以使用 case Circle(radius) 来提取圆形的半径。

模式匹配的高级用法

除了基本的模式匹配之外，Scala 还提供了一些高级的模式匹配用法，可以进一步增强代码的灵活性和可读性。

匹配列表和元组

在 Scala 中，我们可以使用模式匹配来匹配列表和元组的结构。

def processList(list: List[Int]): Unit = list match {
  case Nil => println("Empty list")
  case head :: Nil => println(s"List with only one element:  $head") case head1 :: head2 :: tail => println(s"List with more than one element:$ head1, $head2, ...")
}

val myList1 = List(1, 2, 3)
val myList2 = Nil

processList(myList1) // 输出：List with more than one element: 1, 2, ...
processList(myList2) // 输出：Empty list

在上面的示例中，我们定义了一个 processList 函数，它接受一个整数列表作为输入。通过模式匹配，我们可以根据不同的列表结构执行不同的操作。例如，当输入的列表只有一个元素时，将执行 case head :: Nil => println(s"List with only one element: $head") 这段代码。

类似地，我们也可以使用模式匹配来匹配元组的结构。

val myTuple1 = (1, 2)
val myTuple2 = (1, 2, 3)

myTuple1 match {
  case (a, b) => println(s"Tuple with 2 elements:  $a,$ b")
  case (_, _, c) => println(s"Tuple with 3 elements, the last one is $c")
}

// 输出：Tuple with 2 elements: 1, 2

在上面的示例中，我们使用模式匹配来匹配元组结构。当输入的元组中有两个元素时，将执行 case (a, b) => println(s"Tuple with 2 elements: $a,$ b") 这段代码。

匹配类型和守卫条件

除了值的类型和结构之外，我们还可以使用模式匹配来匹配值的类型和守卫条件。

def processValue(value: Any): Unit = value match {
  case str: String => println(s"A string:  $str") case num: Int if num>0 => println(s"A positive number:$ num")
  case _ => println("Other type")
}

processValue("hello") // 输出：A string: hello
processValue(42)      // 输出：A positive number: 42
processValue(-1)      // 输出：Other type

在上面的示例中，我们定义了一个 processValue 函数，它接受一个任意类型的值作为输入。通过模式匹配，我们可以根据不同的值的类型和守卫条件执行不同的操作。例如，当输入的值是字符串类型时，将执行 case str: String => println(s"A string: $str") 这段代码。