match表达式的定义#

仓颉支持两种match表达式, 第一种是包含待匹配值的match表达式, 第二种是不含待匹配值的match表达式

含匹配值的match表达式:

1
main() {
2
    let x = 0
3
    match (x) {
4
        case 1 => let r1 = "x = 1"
5
                  print(r1)
6
        case 0 => let r2 = "x = 0"                    // Matched
7
                  print(r2)
8
        case _ => let r3 = "x != 1 and x != 0"
9
                  print(r3)
10
    }
11
}

match表达式以关键字match开头, 后跟要匹配的值(如上例中的x, x可以是任意表达式), 接着是定义在一对花括号内的若干case分支

每个case分支以关键字case开头, case之后是一个模式或多个由|连接的相同种类的模式(如上例中的1、0、_都是模式, 详见 模式概述 章节)

match表达式的语法即为:

1
match (待匹配值) {
2
    case 模式1 => ""
3
    case 模式2 | 模式2 => ""
4
}

match表达式的case分支是用于匹配模式的, case之后的模式 可以使用|连接同种模式

模式之后可以接一个可选的pattern guard, 表示本条case匹配成功后额外需要满足的条件, pattern guard使用where cond表示, 要求表达式cond的类型为Bool

接着是一个=>, =>之后即本条case分支匹配成功后需要执行的操作, 可以是一系列表达式、变量和函数定义(新定义的变量或函数的作用域从其定义处开始到下一个case之前结束), 如上例中的变量定义和print函数调用

match表达式执行时, 依次将match之后的表达式与每个case中的模式进行匹配

一旦匹配成功, 则执行=>之后的代码, 然后退出match表达式的执行(意味着不会再去匹配它之后的case)

关于匹配成功, 如果有pattern guard, 也需要where之后的表达式的值为true; 如果case中有多个由|连接的模式, 只要待匹配值和其中一个模式匹配, 则认为匹配成功

如果匹配不成功, 则继续与它之后的case中的模式进行匹配, 直到匹配成功(match表达式可以保证一定存在匹配的case分支)

上例中, 因为x的值等于0, 所以会和第二条case分支匹配(此处使用的是常量模式, 匹配的是值是否相等, 详见 常量模式 章节), 最后输出x = 0

编译并执行上述代码, 输出结果为:

1
x = 0

case模式之后, 还可以接一个pattern guard, 即where cond

所以, match表达式的语法可以是:

1
match (待匹配值) {
2
    case 模式1 where 条件 => ""
3
}

pattern guard中的条件, 必须是Bool类型

在匹配成功之后, 才会进行pattern guard判断, 如果模式是绑定模式, 那么条件中可以使用绑定的变量

match表达式要求 所有匹配必须是穷尽(exhaustive) 的, 意味着 待匹配表达式的所有可能取值都应该被考虑到

当match表达式非穷尽, 或者编译器判断不出是否穷尽时, 均会编译报错, 换言之, 所有case分支(包含pattern guard)所覆盖的取值范围的并集, 应该包含待匹配表达式的所有可能取值

常用的确保match表达式穷尽的方式是在最后一个case分支中使用通配符模式_, 因为_可以匹配任何值

match表达式的穷尽性保证了一定存在 和 待匹配值相匹配 的case分支

下面的例子将编译报错, 因为所有的case并没有覆盖x的所有可能取值:

1
func nonExhaustive(x: Int64) {
2
    match (x) {
3
        case 0 => print("x = 0")
4
        case 1 => print("x = 1")
5
        case 2 => print("x = 2")
6
    }
7
}

如果被匹配值的类型包含enum类型, 且该enum为non-exhaustive enum(包含无名构造器的enum), 则其在匹配时 需要使用可匹配所有构造器的模式, 如通配符模式_和绑定模式

1
enum T {
2
    | Red | Green | Blue | ...
3
}
4
func foo(a: T) {
5
    match (a) {
6
        case Red => 0
7
        case Green => 1
8
        case Blue => 2
9
        case _ => -1
10
    }
11
}
12

13
func bar(a: T) {
14
    match (a) {
15
        case Red => 0
16
        case k => -1              // 简单绑定模式
17
    }
18
}
19

20
func baz(a: T) {
21
    match (a) {
22
        case Red => 0
23
        case k: T => -1           // 带嵌套类型模式的绑定模式
24
    }
25
}

仓颉match表达式, 要求待匹配项必须能够匹配成功, 即 待匹配表达式的所有可能取值都应该被考虑到

即 使用match表达式进行模式匹配, 必须存在至少一个case分支能够匹配成功

如果待匹配项是enum类型, 那么同样需要手动匹配所有构造器, 如果enum存在...无名构造器, 一般就用 通配符_模式 或 绑定模式

当然, 其他类型也可以使用通配符_模式 和 绑定模式进行 匹配所有可能的取值

在case分支的模式之后, 可以使用pattern guard进一步对匹配出来的结果进行判断

在下面的例子中(使用到了enum模式, 详见 enum模式 章节), 当RGBColor的构造器的参数值大于等于0时, 输出它们的值, 当参数值小于0时, 认为它们的值等于0:

1
enum RGBColor {
2
    | Red(Int16) | Green(Int16) | Blue(Int16)
3
}
4
main() {
5
    let c = RGBColor.Green(-100)
6
    let cs = match (c) {
7
        case Red(r) where r < 0 => "Red = 0"
8
        case Red(r)             => "Red = ${r}"
9
        case Green(g) where g < 0 => "Green = 0"      // Matched.
10
        case Green(g)             => "Green = ${g}"
11
        case Blue(b) where b < 0 => "Blue = 0"
12
        case Blue(b)             => "Blue = ${b}"
13
    }
14
    print(cs)
15
}

编译执行上述代码, 输出结果为:

1
Green = 0

pattern guard是在匹配成功之后才进行判断的

没有匹配值的match表达式:

1
main() {
2
    let x = -1
3
    match {
4
        case x > 0 => print("x > 0")
5
        case x < 0 => print("x < 0")          // Matched.
6
        case _ => print("x = 0")
7
    }
8
}

与包含待匹配值的match表达式相比, 关键字match之后并没有待匹配的表达式

并且**case之后不再是pattern**, 而是类型为Bool的表达式(上述代码中的x > 0和x < 0)或者_(表示true), 当然, case中也不再有pattern guard

无匹配值的match表达式执行时, 依次判断case之后的表达式的值, 直到遇到值为true的case分支:

一旦某个case之后的表达式值等于true, 则执行此case中=>之后的代码, 然后退出match表达式的执行(意味着不会再去判断该case之后的其他case)

上例中, 因为x的值等于-1, 所以第二条case分支中的表达式(即x < 0)的值等于true, 执行print("x < 0")

编译并执行上述代码, 输出结果为:

1
x < 0

从文档来看, 无匹配值的match表达式, 更大的用处是 针对可见变量的分支判断, 实际类似if-else

文档中的例子, 实际可以等价于:

1
let x = -1
2
if (x > 0) {
3
    print("x > 0")
4
}
5
else if (x < 0) {
6
    print("x < 0")
7
}
8
else {
9
    print("x = 0")
10
}

match表达式的类型#

对于match表达式(无论是否有匹配值):

• 在上下文有明确的类型要求时, 要求每个case分支中=>之后的代码块的类型是上下文所要求的类型的子类型

• 在上下文没有明确的类型要求时, match表达式的类型是每个case分支中=>之后的代码块的类型的最小公共父类型

• 当match表达式的值没有被使用时, 其类型为Unit, 不要求各分支的类型有最小公共父类型

下面分别举例说明

1
let x = 2
2
let s: String = match (x) {
3
    case 0 => "x = 0"
4
    case 1 => "x = 1"
5
    case _ => "x != 0 and x != 1"             // Matched
6
}

上面的例子中, 定义变量s时, 显式地标注了其类型为String, 属于上下文类型信息明确的情况, 因此要求每个case的=>之后的代码块的类型均是String的子类型, 显然上例中=>之后的字符串类型的字面量均满足要求

再来看一个没有上下文类型信息的例子:

1
let x = 2
2
let s = match (x) {
3
    case 0 => "x = 0"
4
    case 1 => "x = 1"
5
    case _ => "x != 0 and x != 1"             // Matched
6
}

上例中, 定义变量s时, 未显式标注其类型, 因为每个case的=>之后的代码块的类型均是String, 所以match表达式的类型是String, 进而可确定s的类型也是String

match表达式的类型, 与仓颉其他表达式的类型是一致的

如果match表达式的值被使用了:

1. 如果上下文有要求, 每个case分支 的最终类型都要是上下文要求的子类型

2. 如果没有要求, 那么 就是每个case分支的最小公共父类型

如果没有被使用, 就没有任何要求, 类型就是Unit