【华为鸿蒙开发技术】深入理解仓颉语言的模式匹配

在编程语言的设计中，模式匹配是一个非常强大且灵活的特性。仓颉语言也不例外，它提供了丰富的模式匹配语法和功能，帮助开发者更加简洁和高效地处理不同的数据结构和场景。在这篇文章中，我们将详细介绍仓颉语言中支持的各种模式，包括常量模式、通配符模式、绑定模式、tuple模式、类型模式和enum模式。

常量模式

常量模式是最基本的模式之一，它可以是整数字面量、浮点数字面量、字符字面量、布尔字面量、字符串字面量（不支持字符串插值）、Unit字面量。在模式匹配中使用常量模式时，要求常量模式表示的值的类型与待匹配值的类型相同，匹配成功的条件是待匹配的值与常量模式表示的值相等。

main() {
    let score = 90
    let level = match (score) {
        case 0 | 10 | 20 | 30 | 40 | 50 => "D"
        case 60 => "C"
        case 70 | 80 => "B"
        case 90 | 100 => "A" // Matched.
        case _ => "Not a valid score"
    }
    println(level)
}

输出：

A

在这个例子中，我们根据分数score的值来输出考试成绩的等级。分数在不同的区间内会对应不同的等级，最后一个case使用通配符模式来处理无效的分数。

通配符模式

通配符模式使用下划线_表示，可以匹配任意值。通配符模式通常作为最后一个case中的模式，用来匹配其他case未覆盖到的情况。

main() {
    let x = -10
    let y = match (x) {
        case 0 => "zero"
        case _ => "x is not zero" // Matched.
    }
    println(y)
}

输出：

x is not zero

绑定模式

绑定模式使用一个合法的标识符表示，与通配符模式相比，绑定模式同样可以匹配任意值，但绑定模式会将匹配到的值与标识符进行绑定，在=>之后可以通过标识符访问其绑定的值。

main() {
    let x = -10
    let y = match (x) {
        case 0 => "zero"
        case n => "x is not zero and x = ${n}" // Matched.
    }
    println(y)
}

输出：

x is not zero and x = -10

Tuple模式

Tuple模式用于匹配tuple值，它的定义和tuple字面量类似。Tuple模式中的元素可以是常量模式、绑定模式、通配符模式等，多个模式间使用逗号分隔。

main() {
    let tv = ("Alice", 24)
    let s = match (tv) {
        case ("Bob", age) => "Bob is ${age} years old"
        case ("Alice", age) => "Alice is ${age} years old" // Matched.
        case (name, 100) => "${name} is 100 years old"
        case (_, _) => "someone"
    }
    println(s)
}

输出：

Alice is 24 years old

类型模式

类型模式用于判断一个值的运行时类型是否是某个类型的子类型。类型模式有两种形式：_: Type（嵌套一个通配符模式_）和id: Type（嵌套一个绑定模式id）。

open class Base {
    var a: Int64
    public init() {
        a = 10
    }
}

class Derived <: Base {
    public init() {
        a = 20
    }
}

main() {
    var d = Derived()
    var r = match (d) {
        case b: Base => b.a // Matched.
        case _ => 0
    }
    println("r = ${r}")
}

输出：

r = 20

enum模式

enum模式用于匹配enum类型的实例，它的定义和enum的构造器类似。enum模式中的参数可以是常量模式、绑定模式等。

enum TimeUnit {
    | Year(UInt64)
    | Month(UInt64)
}

main() {
    let x = Year(2)
    let s = match (x) {
        case Year(n) => "x has ${n * 12} months" // Matched.
        case TimeUnit.Month(n) => "x has ${n} months"
    }
    println(s)
}

输出：

x has 24 months

模式的Refutability

模式可以分为两类：refutable模式和irrefutable模式。当一个模式有可能和待匹配值不匹配时，称此模式为refutable模式；反之，当一个模式总是可以和待匹配值匹配时，称此模式为irrefutable模式。

func constPat(x: Int64) {
    match (x) {
        case 1 => "one"
        case 2 => "two"
        case _ => "_"
    }
}

func wildcardPat(x: Int64) {
    match (x) {
        case _ => "_"
    }
}

func varPat(x: Int64) {
    match (x) {
        case a => "x = ${a}"
    }
}

通过这些模式，仓颉语言的模式匹配功能得以在不同场景下提供强大的表达能力和简洁的语法，极大地方便了开发者的日常编程工作。希望这篇文章能帮助你更好地理解和使用仓颉语言中的模式匹配特性。

模式的嵌套组合

在仓颉语言中，tuple模式和enum模式可以嵌套使用，组合成更加复杂和灵活的模式。这使得开发者可以对更复杂的数据结构进行匹配和处理。

Tuple模式和enum模式的嵌套

下面的例子展示了tuple模式和enum模式的嵌套使用：

enum TimeUnit {
    | Year(UInt64)
    | Month(UInt64)
}

enum Command {
    | SetTimeUnit(TimeUnit)
    | GetTimeUnit
    | Quit
}

main() {
    let command = SetTimeUnit(Year(2022))
    match (command) {
        case SetTimeUnit(Year(year)) => println("Set year ${year}")
        case SetTimeUnit(Month(month)) => println("Set month ${month}")
        case _ => ()
    }
}

在这个例子中，命令command是一个包含TimeUnit的enum模式。通过嵌套模式匹配，我们可以精确地处理不同的时间单位。

输出：

Set year 2022

模式匹配中的注意事项

在使用模式匹配时，有一些需要注意的事项，以避免编译错误和运行时错误。

重定义错误

在模式匹配中，绑定模式引入的变量在同一个作用域中不能重定义。例如：

main() {
    let x = -10
    let y = match (x) {
        case 0 => "zero"
        case n => let n = 0 // Error, redefinition
                  println(n)
                  "x is not zero"
    }
    println(y)
}

枚举构造器的完全覆盖

在使用match表达式匹配enum值时，要求case之后的模式要覆盖待匹配enum类型中的所有构造器。如果未做到完全覆盖，编译器将报错。例如：

enum RGBColor {
    | Red | Green | Blue
}

main() {
    let c = Green
    let cs = match (c) { // Error, Not all constructors of RGBColor are covered.
        case Red => "Red"
        case Green => "Green"
    }
    println(cs)
}

为了避免这个错误，可以在最后一个case中使用通配符模式_来覆盖未匹配到的情况：

enum RGBColor {
    | Red | Green | Blue
}

main() {
    let c = Blue
    let cs = match (c) {
        case Red => "Red"
        case Green => "Green"
        case _ => "Other" // Matched.
    }
    println(cs)
}

输出：

Other

总结

模式匹配是仓颉语言中的一个重要特性，提供了强大的表达能力和简洁的语法。通过模式匹配，开发者可以轻松处理不同的数据结构和场景，提高代码的可读性和可维护性。在这篇文章中，我们详细介绍了仓颉语言中支持的各种模式及其使用方法，包括常量模式、通配符模式、绑定模式、tuple模式、类型模式和enum模式。同时，我们还讨论了模式的嵌套组合和使用中的注意事项。

希望这篇文章能帮助你更好地理解和掌握仓颉语言中的模式匹配特性，使你的编程工作更加高效和愉快。如果你有任何问题或建议，欢迎在评论区留言。谢谢阅读！