【华为鸿蒙开发技术】仓颉语言中的模式匹配与控制流详解

在编程语言中，模式匹配是一种强大的工具，用于检查数据结构、提取值、并根据特定条件执行相应的操作。仓颉语言提供了灵活且强大的模式匹配机制，通过 match 表达式来实现。本文将详细介绍仓颉语言中的 match 表达式、if-let 表达式、while-let 表达式以及其他使用模式的场景。

1. 含匹配值的 match 表达式

含匹配值的 match 表达式用于将一个值与多个模式进行匹配。它以关键字 match 开头，后跟要匹配的值和定义在一对花括号内的若干 case 分支。

例子：

main() {
    let x = 0
    match (x) {
        case 1 => let r1 = "x = 1"
                  print(r1)
        case 0 => let r2 = "x = 0" // Matched.
                  print(r2)
        case _ => let r3 = "x != 1 and x != 0"
                  print(r3)
    }
}

在这个例子中，x 的值是 0，因此与第二个 case 分支匹配，输出 x = 0。

特点：

• match 表达式需要穷尽所有可能的匹配情况，否则会编译报错。常用的确保方式是在最后一个 case 分支中使用通配符模式 _。
• 每个 case 分支可以包含可选的 pattern guard，用于额外的匹配条件判断。

编译报错的例子：

func nonExhaustive(x: Int64) {
    match (x) {
        case 0 => print("x = 0")
        case 1 => print("x = 1")
        case 2 => print("x = 2")
    }
}

因为缺少对其他值的处理，会导致编译错误。

带 pattern guard 的例子：

enum RGBColor {
    | Red(Int16) | Green(Int16) | Blue(Int16)
}
main() {
    let c = RGBColor.Green(-100)
    let cs = match (c) {
        case Red(r) where r < 0 => "Red = 0"
        case Red(r) => "Red = ${r}"
        case Green(g) where g < 0 => "Green = 0" // Matched.
        case Green(g) => "Green = ${g}"
        case Blue(b) where b < 0 => "Blue = 0"
        case Blue(b) => "Blue = ${b}"
    }
    print(cs)
}

输出：

Green = 0

2. 无匹配值的 match 表达式

这种 match 表达式不匹配具体值，而是依次判断 case 分支中的布尔表达式，直到找到值为 true 的分支。

例子：

main() {
    let x = -1
    match {
        case x > 0 => print("x > 0")
        case x < 0 => print("x < 0") // Matched.
        case _ => print("x = 0")
    }
}

输出：

x < 0

3. if-let 表达式

if-let 表达式用于条件判断，并在模式匹配成功时执行特定代码。格式为 if (let pattern <- expression) { ... } else { ... }。

例子：

main() {
    let result = Option<Int64>.Some(2023)

    if (let Some(value) <- result) {
        println("操作成功，返回值为：${value}")
    } else {
        println("操作失败")
    }
}

输出：

操作成功，返回值为：2023

另一个例子：

main() {
    let result = Option<Int64>.None

    if (let Some(value) <- result) {
        println("操作成功，返回值为：${value}")
    } else {
        println("操作失败")
    }
}

输出：

操作失败

4. while-let 表达式

while-let 表达式用于循环条件判断，并在模式匹配成功时执行循环体。格式为 while (let pattern <- expression) { ... }。

例子：

import std.random.*

func recv(): Option<UInt8> {
    let number = Random().nextUInt8()
    if (number < 128) {
        return Some(number)
    }
    return None
}

main() {
    while (let Some(data) <- recv()) {
        println(data)
    }
    println("receive failed")
}

输出示例：

73
94
receive failed

5. 其他使用模式的地方

模式不仅可以在 match 表达式中使用，还可以在变量定义和 for in 表达式中使用。但只有不可反驳（irrefutable）的模式才可以在这些地方使用，例如通配符模式、绑定模式、不可反驳的元组模式和枚举模式。

例子：

通配符模式：

main() {
    let _ = 100
    for (_ in 1..5) {
        println("0")
    }
}

输出：

0
0
0
0

绑定模式：

main() {
    let x = 100
    println("x = ${x}")
    for (i in 1..5) {
        println(i)
    }
}

输出：

x = 100
1
2
3
4

不可反驳的元组模式：

main() {
    let (x, y) = (100, 200)
    println("x = ${x}")
    println("y = ${y}")
    for ((i, j) in [(1, 2), (3, 4), (5, 6)]) {
        println("Sum = ${i + j}")
    }
}

输出：

x = 100
y = 200
Sum = 3
Sum = 7
Sum = 11

不可反驳的枚举模式：

enum RedColor {
    Red(Int64)
}
main() {
    let Red(red) = Red(0)
    println("red = ${red}")
    for (Red(r) in [Red(10), Red(20), Red(30)]) {
        println("r = ${r}")
    }
}

输出：

red = 0
r = 10
r = 20
r = 30

6. 使用模式的实战案例

为了更好地理解和应用仓颉语言中的模式匹配技术，我们来看一些实际的应用场景和案例。

案例 1：解析命令行参数

在处理命令行参数时，我们经常需要根据不同的参数执行不同的操作。使用 match 表达式可以使代码更加清晰。

enum Command {
    | Help
    | Version
    | Unknown
}

func parseArgs(args: List<String>): Command {
    if (args.isEmpty()) {
        return Command.Help
    }
    match (args[0]) {
        case "--help" => Command.Help
        case "--version" => Command.Version
        case _ => Command.Unknown
    }
}

main() {
    let args = ["--version"]
    let command = parseArgs(args)
    
    match (command) {
        case Command.Help => println("Usage: program [--help] [--version]")
        case Command.Version => println("Program version 1.0")
        case Command.Unknown => println("Unknown command")
    }
}

输出：

Program version 1.0

案例 2：处理网络请求结果

在处理网络请求时，结果可能是成功、失败或超时等多种情况。使用 match 表达式可以简化这些逻辑判断。

enum NetworkResult {
    | Success(String)
    | Failure(String)
    | Timeout
}

func handleRequest(url: String): NetworkResult {
    // 模拟不同的网络请求结果
    let status = Random().nextInt(3)
    match (status) {
        case 0 => NetworkResult.Success("Data from ${url}")
        case 1 => NetworkResult.Failure("Failed to connect to ${url}")
        case 2 => NetworkResult.Timeout
    }
}

main() {
    let result = handleRequest("https://example.com")

    match (result) {
        case NetworkResult.Success(data) => println("Request successful: ${data}")
        case NetworkResult.Failure(error) => println("Request failed: ${error}")
        case NetworkResult.Timeout => println("Request timed out")
    }
}

输出示例：

Request successful: Data from https://example.com

案例 3：解析 JSON 数据

在解析 JSON 数据时，可能需要根据数据结构的不同部分进行不同的处理。match 表达式可以帮助我们高效地解析和处理 JSON 数据。

enum Json {
    | JsonObject(Map<String, Json>)
    | JsonArray(List<Json>)
    | JsonString(String)
    | JsonNumber(Int64)
    | JsonBoolean(Bool)
    | JsonNull
}

func parseJson(json: Json) {
    match (json) {
        case JsonObject(obj) => 
            println("Object with ${obj.size()} keys")
            for ((key, value) in obj) {
                println("${key} : ${value}")
            }
        case JsonArray(arr) => 
            println("Array with ${arr.size()} elements")
            for (element in arr) {
                println("Element: ${element}")
            }
        case JsonString(str) => println("String: ${str}")
        case JsonNumber(num) => println("Number: ${num}")
        case JsonBoolean(bool) => println("Boolean: ${bool}")
        case JsonNull => println("Null")
    }
}

main() {
    let json = JsonObject({
        "name" => JsonString("John Doe"),
        "age" => JsonNumber(30),
        "isStudent" => JsonBoolean(false),
        "courses" => JsonArray([
            JsonString("Math"),
            JsonString("Science")
        ])
    })

    parseJson(json)
}

输出：

Object with 4 keys
name : JsonString(John Doe)
age : JsonNumber(30)
isStudent : JsonBoolean(false)
courses : JsonArray([JsonString(Math), JsonString(Science)])

结论

通过这些案例，我们可以看到仓颉语言中的模式匹配在处理不同类型的数据和逻辑判断时的强大和灵活性。无论是解析命令行参数、处理网络请求结果，还是解析复杂的 JSON 数据，仓颉语言的模式匹配机制都能使代码更加简洁、直观和易于维护。

在实际开发中，掌握并灵活运用这些模式匹配技术，可以大大提升代码的质量和开发效率。希望本文能够帮助您深入理解和应用仓颉语言中的模式匹配，为您的开发工作提供有力的支持。

继续探索仓颉语言的更多特性和应用场景，充分发挥它的潜力，相信您会发现更多有趣和高效的编程技巧。