Rust 中文社区 · 更新于 2017-11-20 11:00:52

模式

模式,是Rust另一个强大的特性。它可以被用在letmatch表达式里面。相信大家应该还记得我们在复合类型中提到的关于在let表达式中解构元组的例子,实际上这就是一个模式。

let tup = (0u8, 1u8);
let (x, y) = tup;

而且我们需要知道的是,如果一个模式中出现了和当前作用域中已存在的同名的绑定,那么它会覆盖掉外部的绑定。比如:

let x = 1;
let c = 'c';

match c {
    x => println!("x: {} c: {}", x, c),
}

println!("x: {}", x);

它的输出结果是:

x: c c: c
x: 1

在以上代码中,match作用域里的x这个绑定被覆盖成了'c',而出了这个作用域,绑定x又恢复为1。这和变量绑定的行为是一致的。

更强大的解构

在上一节里,我们初步了解了模式匹配在解构enum时候的便利性,事实上,在Rust中模式可以被用来对任何复合类型进行解构——struct/tuple/enum。现在我们要讲述一个复杂点的例子,对struct进行解构。

首先,我们可以对一个结构体进行标准的解构:

struct Point {
    x: i64,
    y: i64,
}
let point = Point { x: 0, y: 0 };
match point {
    Point { x, y } => println!("({},{})", x, y),
}

最终,我们拿到了Point内部的值。有人说了,那我想改个名字怎么办? 很简单,你可以使用 :来对一个struct的字段进行重命名,如下:

struct Point {
    x: i64,
    y: i64,
}
let point = Point { x: 0, y: 0 };
match point {
    Point { x: x1, y: y1} => println!("({},{})", x1, y1),
}

另外,有的时候我们其实只对某些字段感兴趣,就可以用..来省略其他字段。

struct Point {
    x: i64,
    y: i64,
}

let point = Point { x: 0, y: 0 };

match point {
    Point { y, .. } => println!("y is {}", y),
}

忽略和内存管理

总结一下,我们遇到了两种不同的模式忽略的情况——_..。这里要注意,模式匹配中被忽略的字段是不会被move的,而且实现Copy的也会优先被Copy而不是被move

说的有点拗口,上代码:

let tuple: (u32, String) = (5, String::from("five"));

let (x, s) = tuple;

// 以下行将导致编译错误,因为String类型并未实现Copy, 所以tuple被整体move掉了。
// println!("Tuple is: {:?}", tuple);

let tuple = (5, String::from("five"));

// 忽略String类型,而u32实现了Copy,则tuple不会被move
let (x, _) = tuple;

println!("Tuple is: {:?}", tuple);

范围和多重匹配

模式匹配可以被用来匹配单种可能,当然也就能被用来匹配多种情况:

范围

在模式匹配中,当我想要匹配一个数字(字符)范围的时候,我们可以用...来表示:

let x = 1;

match x {
    1 ... 10 => println!("一到十"),
    _ => println!("其它"),
}

let c = 'w';

match c {
    'a' ... 'z' => println!("小写字母"),
    'A' ... 'Z' => println!("大写字母"),
    _ => println!("其他字符"),
}

多重匹配

当我们只是单纯的想要匹配多种情况的时候,可以使用 | 来分隔多个匹配条件

let x = 1;

match x {
    1 | 2 => println!("一或二"),
    _ => println!("其他"),
}

ref 和 ref mut

前面我们了解到,当被模式匹配命中的时候,未实现Copy的类型会被默认的move掉,因此,原owner就不再持有其所有权。但是有些时候,我们只想要从中拿到一个变量的(可变)引用,而不想将其move出作用域,怎么做呢?答:用ref或者ref mut

let mut x = 5;

match x {
    ref mut mr => println!("mut ref :{}", mr),
}
// 当然了……在let表达式里也能用
let ref mut mrx = x;

变量绑定

在模式匹配的过程内部,我们可以用@来绑定一个变量名,这在复杂的模式匹配中是再方便不过的,比如一个具名的范围匹配如下:

let x = 1u32;
match x {
    e @ 1 ... 5 | e @ 10 ... 15 => println!("get:{}", e),
    _ => (),
}

如代码所示,e绑定了x的值。

当然,变量绑定是一个极其有用的语法,下面是一个来自官方doc里的例子:

#[derive(Debug)]
struct Person {
    name: Option<String>,
}

let name = "Steve".to_string();
let x: Option<Person> = Some(Person { name: Some(name) });
match x {
    Some(Person { name: ref a @ Some(_), .. }) => println!("{:?}", a),
    _ => {}
}

输出:

Some("Steve")

后置条件

一个后置的if表达式可以被放在match的模式之后,被称为match guards。例如如下代码:

let x = 4;
let y = false;

match x {
    4 | 5 if y => println!("yes"),
    _ => println!("no"),
}

猜一下上面代码的输出?

答案是no。因为guard是后置条件,是整个匹配的后置条件:所以上面的式子表达的逻辑实际上是:

// 伪代码表示
IF y AND (x IN List[4, 5])
上一篇: match关键字 下一篇: 特征 Trait