HarmonyOS Next模式匹配核心：常量与通配符的精准控制

模式匹配是仓颉语言处理复杂逻辑的利器，其中常量模式与通配符模式构成了类型安全匹配的基础。本文将通过实战案例解析这两种模式的语法规则与应用场景，帮助开发者掌握精准值匹配与灵活兜底的核心技巧。

一、常量模式：精准值匹配的实现

1. 支持的字面量匹配类型

类型	匹配示例	核心特性
整数	case 0, case 100	精确数值相等匹配
字符串	case "ok", case 'A'	内容相等匹配
布尔值	case true	逻辑值匹配
枚举构造器	case Direction.Up	枚举实例精准匹配

2. 多值与范围匹配语法

通过|连接多值，用..定义范围（左闭右开）：

let score = 85
let grade = match score {
    case 90..100 => "A"       // 范围匹配90-99
        case 80 | 85 | 90 => "B" // 多值精准匹配
            case 60..80 => "C"       // 60-79
                case _ => "D"             // 通配符兜底
                }
                // grade结果为"B"
                ```
### 3. 枚举类型的常量匹配  
无参枚举构造器可直接匹配，支持隐式类型推导：  
```cj
enum Direction { | Up | Down | Left | Right }

func move(dir: Direction) {
    match dir {
            case Up => println("向上")
                    case Down => println("向下")
                            case Left | Right => println("水平移动")
                                }
                                }
move(dir: .Right)  // 输出"水平移动"

二、通配符模式：灵活兜底的万能方案

1. 枚举匹配的必选兜底

编译器强制要求枚举匹配覆盖所有情况，通配符处理未显式匹配的构造器：

enum Color { | Red | Green | Blue }

func showColor(c: Color) {
    match c {
            case Red => print("红")
                    case Green => print("绿")
                            case _ => print("蓝")  // 必须添加，否则编译报错
                                }
                                }
                                ```
### 2. 解构中的无关值忽略  
通配符在解构时忽略不需要的变量：  
```cj
let (x, _) = (10, 20)  // 只获取x=10
println(x)  // 输出10

for (_ in 0..5) {  // 忽略循环索引
    println("迭代")
    }
    ```
### 3. 带参数枚举的部分匹配  
匹配构造器但忽略参数，简化逻辑：  
```cj
enum Command { | Ping | Pong(Int) | Error(String) }

func process(cmd: Command) {
    match cmd {
            case Ping => print("收到Ping")
                    case Pong(_) => print("收到Pong")  // 忽略参数
                            case Error(msg) => print("错误：\(msg)")
                                }
                                }
process(cmd: .Pong(123))  // 输出"收到Pong"

三、类型安全的穷尽性检查

1. 枚举匹配的强制覆盖

未覆盖所有枚举构造器且无通配符时，编译器报错：

enum State { | Idle | Working | Error }

func update(state: State) {
    match state {
            case Idle => print("空闲")
                    case Working => print("工作")
                            // 编译错误：未处理Error状态
                                }
                                }
                                ```
### 2. 数值匹配的边界处理  
通配符处理未定义的数值范围：  
```cj
func check(n: Int) {
    match n {
            case 1..100 => print("有效")
                    case _ => print("无效")  // 处理所有其他值
                        }
                        }
                        ```
### 3. 匹配顺序优化  
高频条件优先匹配，提升执行效率：  
```cj
enum Event { | Click | DoubleClick | LongPress }

func handle(e: Event) {
    match e {
            case DoubleClick => print("双击")  // 高频操作优先
                    case Click => print("单击")
                            case LongPress => print("长按")
                                }
                                }
                                ```

## 四、实战场景：模式组合应用  

### 1. 协议指令解析  
常量模式匹配固定指令，通配符处理扩展指令：  
```cj
enum Protocol { | Get("get") | Post("post") | Other(String) }

func parse(cmd: String) {
    match cmd {
            case Protocol.Get => print("处理GET")
                    case Protocol.Post => print("处理POST")
                            case Other(p) => print("未知协议：\(p)")
                                }
                                }
parse(cmd: "put")  // 输出"未知协议：put"

2. 状态机默认行为

通配符增强状态机的健壮性：

enum Machine { | Run | Stop | Pause(Int) }

func control(m: Machine) {
    match m {
            case Run => start()
                    case Stop => end()
                            case Pause(t) => wait(t)
                                    case _ => error()  // 理论不可达，增强鲁棒性
                                        }
                                        }
                                        ```

## 总结  
常量模式与通配符模式构成了模式匹配的基础能力：  
- 常量模式通过字面量实现精准值匹配，适用于枚举状态、协议指令等场景  
- - 通配符模式确保逻辑完整性，是处理默认情况和类型安全的必备工具  
- - 编译器的穷尽性检查机制，从源头避免运行时逻辑漏洞  
掌握这两种模式的协同使用，能让代码在保持简洁的同时，兼具类型安全与可维护性。