Scala模式匹配完全指南：从基础语法到高级应用

Scala模式匹配完全指南：从基础语法到高级应用

• • 1. 引言：比switch更强大的武器
  • 2. 模式匹配基础
  • • 2.1 基本语法
    • 2.2 最简单的例子
  • 3. 模式匹配的常见用法
  • • 3.1 匹配常量
    • 3.2 匹配变量
    • 3.3 匹配类型
    • 3.4 匹配case class（最常用）
    • 3.5 匹配集合
    • 3.6 带守卫条件的匹配
    • 3.7 匹配正则表达式
    • 3.8 密封类的模式匹配
  • 4. 模式匹配的执行流程图
  • 5. 高级应用：函数字面量中的模式匹配
  • • 5.1 在匿名函数中使用
    • 5.2 偏函数中的模式匹配
  • 6. 实际应用案例
  • • 6.1 表达式求值器
    • 6.2 JSON解析器
    • 6.3 状态机实现
  • 7. 最佳实践与注意事项
  • • 7.1 匹配顺序很重要
    • 7.2 使用@绑定嵌套值
    • 7.3 使用下划线的几种情况
    • 7.4 完整性与警告
  • 8. 总结
  • • 8.1 模式匹配的核心优势
    • 8.2 使用场景速查
    • 8.3 最终建议

1. 引言：比switch更强大的武器

如果你来自Java或C语言背景，你一定熟悉switch语句——根据一个变量的值，选择不同的执行分支。Scala中的**模式匹配（Pattern Matching）**远不止于此，它是这门语言最强大的特性之一。

// Java的switch
switch (day) {
case MONDAY:
case FRIDAY:
System.out.println("工作");
break;
case SATURDAY:
case SUNDAY:
System.out.println("休息");
break;
default:
System.out.println("未知");
}

// Scala的模式匹配
day match {
case "MONDAY" | "FRIDAY" => println("工作")
case "SATURDAY" | "SUNDAY" => println("休息")
case _ => println("未知")
}

这看起来只是语法上的改进，但模式匹配的真正威力在于它可以：

• 解构复杂数据结构
• 匹配类型和结构
• 提取值
• 与case class完美配合

本文将系统介绍Scala模式匹配的方方面面，从基础语法到高级应用，带你掌握这个函数式编程的核心利器。

2. 模式匹配基础

2.1 基本语法

目标值 match {
case 模式1 => 结果1
case 模式2 => 结果2
case 模式3 if 守卫条件 => 结果3
case _ => 默认结果
}

执行流程：

#mermaid-svg-oUuLFQP295wo30QW{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-oUuLFQP295wo30QW .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-oUuLFQP295wo30QW .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-oUuLFQP295wo30QW .error-icon{fill:#552222;}#mermaid-svg-oUuLFQP295wo30QW .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-oUuLFQP295wo30QW .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-oUuLFQP295wo30QW .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-oUuLFQP295wo30QW .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-oUuLFQP295wo30QW .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-oUuLFQP295wo30QW .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-oUuLFQP295wo30QW .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-oUuLFQP295wo30QW .marker{fill:#333333;stroke:#333333;}#mermaid-svg-oUuLFQP295wo30QW .marker.cross{stroke:#333333;}#mermaid-svg-oUuLFQP295wo30QW svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-oUuLFQP295wo30QW p{margin:0;}#mermaid-svg-oUuLFQP295wo30QW .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-oUuLFQP295wo30QW .cluster-label text{fill:#333;}#mermaid-svg-oUuLFQP295wo30QW .cluster-label span{color:#333;}#mermaid-svg-oUuLFQP295wo30QW .cluster-label span p{background-color:transparent;}#mermaid-svg-oUuLFQP295wo30QW .label text,#mermaid-svg-oUuLFQP295wo30QW span{fill:#333;color:#333;}#mermaid-svg-oUuLFQP295wo30QW .node rect,#mermaid-svg-oUuLFQP295wo30QW .node circle,#mermaid-svg-oUuLFQP295wo30QW .node ellipse,#mermaid-svg-oUuLFQP295wo30QW .node polygon,#mermaid-svg-oUuLFQP295wo30QW .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-oUuLFQP295wo30QW .rough-node .label text,#mermaid-svg-oUuLFQP295wo30QW .node .label text,#mermaid-svg-oUuLFQP295wo30QW .image-shape .label,#mermaid-svg-oUuLFQP295wo30QW .icon-shape .label{text-anchor:middle;}#mermaid-svg-oUuLFQP295wo30QW .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-oUuLFQP295wo30QW .rough-node .label,#mermaid-svg-oUuLFQP295wo30QW .node .label,#mermaid-svg-oUuLFQP295wo30QW .image-shape .label,#mermaid-svg-oUuLFQP295wo30QW .icon-shape .label{text-align:center;}#mermaid-svg-oUuLFQP295wo30QW .node.clickable{cursor:pointer;}#mermaid-svg-oUuLFQP295wo30QW .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-oUuLFQP295wo30QW .arrowheadPath{fill:#333333;}#mermaid-svg-oUuLFQP295wo30QW .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-oUuLFQP295wo30QW .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-oUuLFQP295wo30QW .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-oUuLFQP295wo30QW .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-oUuLFQP295wo30QW .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-oUuLFQP295wo30QW .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-oUuLFQP295wo30QW .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-oUuLFQP295wo30QW .cluster text{fill:#333;}#mermaid-svg-oUuLFQP295wo30QW .cluster span{color:#333;}#mermaid-svg-oUuLFQP295wo30QW div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-oUuLFQP295wo30QW .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-oUuLFQP295wo30QW rect.text{fill:none;stroke-width:0;}#mermaid-svg-oUuLFQP295wo30QW .icon-shape,#mermaid-svg-oUuLFQP295wo30QW .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-oUuLFQP295wo30QW .icon-shape p,#mermaid-svg-oUuLFQP295wo30QW .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-oUuLFQP295wo30QW .icon-shape .label rect,#mermaid-svg-oUuLFQP295wo30QW .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-oUuLFQP295wo30QW .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-oUuLFQP295wo30QW .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-oUuLFQP295wo30QW :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

成功

失败

成功

失败

全部失败

目标值

匹配模式1

执行结果1

匹配模式2

执行结果2

匹配模式3…

执行默认分支

2.2 最简单的例子

def describe(x: Any): String = x match {
case 0 => "零"
case 1 => "一"
case "hello" => "你好"
case true => "真"
case false => "假"
case _ => "其他"
}

println(describe(0)) // 零
println(describe("hello")) // 你好
println(describe(3.14)) // 其他

3. 模式匹配的常见用法

3.1 匹配常量

最简单的用法，匹配具体的字面量：

def weekdayName(day: Int): String = day match {
case 1 => "星期一"
case 2 => "星期二"
case 3 => "星期三"
case 4 => "星期四"
case 5 => "星期五"
case 6 => "星期六"
case 7 => "星期日"
case _ => "无效的星期"
}

// 多值匹配
def isWeekend(day: String): Boolean = day match {
case "星期六" | "星期日" => true
case _ => false
}

3.2 匹配变量

如果匹配模式是一个小写字母开头的标识符，它会捕获匹配的值：

def describeNumber(x: Int): String = x match {
case 0 => "零"
case n if n > 0 => s"正数: $n"
case n if n < 0 => s"负数: $n"
}

// 捕获值并在右侧使用
def greet(person: Any): String = person match {
case name: String => s"Hello, $name"
case age: Int if age < 18 => s"小朋友，你$age岁"
case age: Int => s"你好，$age岁的朋友"
case _ => "你好"
}

3.3 匹配类型

def typeInfo(x: Any): String = x match {
case _: String => "这是一个字符串"
case _: Int => "这是一个整数"
case _: Double => "这是一个双精度浮点数"
case _: Boolean => "这是一个布尔值"
case _: List[_] => "这是一个列表"
case _: Array[_] => "这是一个数组"
case _ => "未知类型"
}

println(typeInfo("hello")) // 这是一个字符串
println(typeInfo(42)) // 这是一个整数
println(typeInfo(List(1,2,3))) // 这是一个列表

3.4 匹配case class（最常用）

这是模式匹配最强大的应用场景之一，与case class完美配合：

// 定义case class
case class Person(name: String, age: Int)
case class Address(city: String, street: String)
case class User(person: Person, address: Address)

// 匹配并提取字段
def describePerson(p: Person): String = p match {
case Person("Alice", age) => s"Alice, 年龄 $age"
case Person(name, 18) => s"$name 刚好18岁"
case Person(name, age) if age < 18 => s"未成年: $name"
case Person(name, age) => s"$name 年龄 $age"
}

// 嵌套匹配
def describeUser(u: User): String = u match {
case User(Person(name, age), Address("北京", street)) =>
s"$name 住在北京 $street"
case User(Person(name, age), Address(city, _)) =>
s"$name 住在 $city"
}

3.5 匹配集合

匹配列表：

def listInfo(list: List[Int]): String = list match {
case Nil => "空列表"
case head :: Nil => s"只有一个元素: $head"
case head :: tail => s"第一个元素: $head, 剩余元素个数: ${tail.length}"
case _ => "其他情况"
}

// 更复杂的列表匹配
def processList(list: List[Any]): String = list match {
case List(1, 2, 3) => "精确匹配 [1,2,3]"
case List(a, b, c) => s"有三个元素: $a, $b, $c"
case 1 :: 2 :: tail => "以1,2开头"
case a :: b :: Nil => s"两个元素: $a, $b"
case _ => "其他"
}

匹配数组：

def arrayInfo(arr: Array[Int]): String = arr match {
case Array() => "空数组"
case Array(x) => s"单个元素: $x"
case Array(x, y) => s"两个元素: $x, $y"
case Array(x, y, _*) => s"至少两个元素, 第一个: $x, 第二个: $y"
}

匹配元组：

def tupleInfo(t: Any): String = t match {
case (a, b) => s"二元组: ($a, $b)"
case (a, b, c) => s"三元组: ($a, $b, $c)"
case (a, b, c, d) => s"四元组: ($a, $b, $c, $d)"
case _ => "不是元组或元组元素过多"
}

// 匹配特定模式的元组
val coordinate = (10, 20, "point")
coordinate match {
case (x, y, "point") => s"点坐标: ($x, $y)"
case (x, y, z) => s"三维坐标: ($x, $y, $z)"
}

3.6 带守卫条件的匹配

def temperatureCategory(temp: Int): String = temp match {
case t if t < 0 => "零下"
case t if t >= 0 && t <= 20 => "凉爽"
case t if t > 20 && t <= 30 => "温暖"
case t if t > 30 => "炎热"
}

// 结合case class
case class Order(amount: Double, prime: Boolean)

def discount(order: Order): Double = order match {
case Order(amount, true) if amount > 1000 => amount * 0.7 // 会员满1000打7折
case Order(amount, true) => amount * 0.9 // 会员打9折
case Order(amount, false) if amount > 2000 => amount * 0.8 // 非会员满2000打8折
case Order(amount, false) => amount // 无折扣
}

3.7 匹配正则表达式

import scala.util.matching.Regex

val emailRegex: Regex = """(.+)@(.+)\\.(.+)""".r
val phoneRegex: Regex = """(\\d{3})-(\\d{8})""".r

def parseContact(contact: String): String = contact match {
case emailRegex(name, domain, ext) =>
s"邮箱: 用户名=$name, 域名=$domain, 后缀=$ext"
case phoneRegex(area, number) =>
s"电话: 区号=$area, 号码=$number"
case _ =>
s"未知格式: $contact"
}

println(parseContact("john@example.com"))
// 邮箱: 用户名=john, 域名=example, 后缀=com

println(parseContact("010-12345678"))
// 电话: 区号=010, 号码=12345678

3.8 密封类的模式匹配

当与sealed class一起使用时，编译器可以检查匹配是否完整：

sealed trait Animal
case class Dog(name: String) extends Animal
case class Cat(name: String) extends Animal
case class Bird(name: String) extends Animal

// 编译器会警告如果匹配不完整
def sound(animal: Animal): String = animal match {
case Dog(name) => s"$name 汪汪叫"
case Cat(name) => s"$name 喵喵叫"
case Bird(name) => s"$name 啾啾叫"
// 如果漏掉Bird，编译器会警告
}

4. 模式匹配的执行流程图

渲染错误: Mermaid 渲染失败: Parse error on line 2: …TD A[目标值: Person("Alice", 25)] –> B ———————-^ Expecting 'SQE', 'DOUBLECIRCLEEND', 'PE', '-)', 'STADIUMEND', 'SUBROUTINEEND', 'PIPE', 'CYLINDEREND', 'DIAMOND_STOP', 'TAGEND', 'TRAPEND', 'INVTRAPEND', 'UNICODE_TEXT', 'TEXT', 'TAGSTART', got 'PS'

5. 高级应用：函数字面量中的模式匹配

5.1 在匿名函数中使用

val list = List(Some(1), None, Some(2), None, Some(3))

// 普通方式
val filtered = list.filter {
case Some(x) => x > 1
case None => false
}

// 提取值
val extracted = list.map {
case Some(x) => x
case None => 0
}
println(extracted) // List(1, 0, 2, 0, 3)

// 与collect结合：同时过滤和转换
val positives = list.collect {
case Some(x) if x > 1 => x * 2
}
println(positives) // List(4, 6)

5.2 偏函数中的模式匹配

// 定义一个偏函数
val pf: PartialFunction[Any, String] = {
case i: Int if i > 0 => s"正整数: $i"
case s: String => s"字符串: $s"
case list: List[_] if list.nonEmpty => s"非空列表: $list"
}

// 测试
println(pf(42)) // 正整数: 42
println(pf("hello")) // 字符串: hello
println(pf(List(1,2))) // 非空列表: List(1, 2)

// isDefinedAt 检查是否匹配
println(pf.isDefinedAt(–5)) // false
println(pf.isDefinedAt("test")) // true

6. 实际应用案例

6.1 表达式求值器

sealed trait Expr
case class Number(value: Int) extends Expr
case class Add(left: Expr, right: Expr) extends Expr
case class Subtract(left: Expr, right: Expr) extends Expr
case class Multiply(left: Expr, right: Expr) extends Expr
case class Divide(left: Expr, right: Expr) extends Expr

def evaluate(expr: Expr): Int = expr match {
case Number(v) => v
case Add(l, r) => evaluate(l) + evaluate(r)
case Subtract(l, r) => evaluate(l) – evaluate(r)
case Multiply(l, r) => evaluate(l) * evaluate(r)
case Divide(l, r) =>
val right = evaluate(r)
if (right == 0) throw new ArithmeticException("除以0")
evaluate(l) / right
}

// 使用
val expr = Add(Number(5), Multiply(Number(3), Number(2)))
println(evaluate(expr)) // 5 + (3 * 2) = 11

6.2 JSON解析器

sealed trait Json
case class JsonObject(fields: Map[String, Json]) extends Json
case class JsonArray(items: List[Json]) extends Json
case class JsonString(value: String) extends Json
case class JsonNumber(value: Double) extends Json
case class JsonBoolean(value: Boolean) extends Json
case object JsonNull extends Json

def prettyPrint(json: Json, indent: Int = 0): String = {
val spaces = " " * indent

json match {
case JsonObject(fields) =>
val fieldStrings = fields.map { case (k, v) =>
s"$spaces \\"$k\\": ${prettyPrint(v, indent + 2)}"
}.mkString(",\\n")
s"{\\n$fieldStrings\\n$spaces}"

case JsonArray(items) =>
val itemStrings = items.map(prettyPrint(_, indent + 2))
.mkString(s",\\n$spaces ")
s"[\\n$spaces $itemStrings\\n$spaces]"

case JsonString(s) => s"\\"$s\\""
case JsonNumber(n) => n.toString
case JsonBoolean(b) => b.toString
case JsonNull => "null"
}
}

// 使用
val data = JsonObject(Map(
"name" -> JsonString("Alice"),
"age" -> JsonNumber(25),
"hobbies" -> JsonArray(List(
JsonString("reading"),
JsonString("swimming")
))
))
println(prettyPrint(data))

6.3 状态机实现

sealed trait State
case object Idle extends State
case object Running extends State
case object Paused extends State
case object Stopped extends State

sealed trait Event
case object Start extends Event
case object Pause extends Event
case object Resume extends Event
case object Stop extends Event

class StateMachine {
private var currentState: State = Idle

def handle(event: Event): String = (currentState, event) match {
case (Idle, Start) =>
currentState = Running
"启动成功"

case (Running, Pause) =>
currentState = Paused
"已暂停"

case (Paused, Resume) =>
currentState = Running
"恢复运行"

case (Running | Paused, Stop) =>
currentState = Stopped
"已停止"

case (Stopped, Start) =>
currentState = Running
"重新启动"

case (state, event) =>
s"非法事件: 当前状态 $state 不能处理 $event"
}
}

// 使用
val sm = new StateMachine()
println(sm.handle(Start)) // 启动成功
println(sm.handle(Pause)) // 已暂停
println(sm.handle(Resume)) // 恢复运行
println(sm.handle(Stop)) // 已停止
println(sm.handle(Pause)) // 非法事件: 当前状态 Stopped 不能处理 Pause

7. 最佳实践与注意事项

7.1 匹配顺序很重要

def carefulMatch(x: Any): String = x match {
case s: String => s"字符串: $s"
case s: String if s.startsWith("A") => "以A开头的字符串" // 永远匹配不到！
case _ => "其他"
}

规则：模式按顺序匹配，第一个匹配的生效。更具体的模式应该放在前面。

7.2 使用@绑定嵌套值

case class Address(city: String, street: String)
case class Person(name: String, address: Address)

def describe(p: Person): String = p match {
case Person(name, addr @ Address(city, street)) =>
s"$name 住在 $city $street, 完整地址: $addr"
}

7.3 使用下划线的几种情况

// 1. 通配符，匹配任意值但不使用
case _ => "默认"

// 2. 类型匹配时不关心具体值
case _: String => "字符串"

// 3. 序列模式中匹配剩余元素
case List(_, _, rest @ _*) => s"至少两个元素, 剩余: $rest"

// 4. 忽略某个字段
case Person(name, _) => s"$name"

7.4 完整性与警告

对于密封类（sealed class），编译器可以检查匹配是否完整：

sealed trait Color
case object Red extends Color
case object Green extends Color
case object Blue extends Color

def toRGB(color: Color): String = color match {
case Red => "#FF0000"
case Green => "#00FF00"
// 警告: match may not be exhaustive. 缺少 Blue
}

8. 总结

8.1 模式匹配的核心优势

8.2 使用场景速查

8.3 最终建议

模式匹配是Scala语言的标志性特性之一，掌握它将极大地提升你的代码表达能力和函数式编程水平。