Rust 一行 entry() 干掉五行 if/else

假设有个需求，要统计请求日志里每个 URL 出现了多少次。

听起来非常 easy 对吧，动手写一下：

use std::collections::HashMap;

fn main() {
    let requests = ["/login", "/products", "/login", "/login"];
    let mut counts: HashMap<&str, usize> = HashMap::new();
    for path in requests {
        if counts.contains_key(path) {
            let count = counts.get_mut(path).unwrap();
            *count += 1;
        } else {
            counts.insert(path, 1);
        }
    }
    assert_eq!(counts["/login"], 3);
}

代码逻辑很简单。先看 URL 在不在表里。在的话就把次数加一，否则插入一条记录，次数记为一。

不过，你有没有发现，当 URL 已经在表里时，这段代码会把它查两遍：先问这张表"有没有它"（contains_key），等它答"有"，再让它把同一个 URL 找出来（get_mut）。

但如果我们用另一个方法，可以缩成一行：

*counts.entry(path).or_insert(0) += 1;

注意，星号解引用的是 or_insert(0) 返回的可变引用。

计数结果一样，省了单独的存在性检查，也省了 unwrap() 和自己维护的判断分支。

问题就这样解决了。不过，在你到处用这个写法之前，我们应该先弄清楚两件事：

1. Rust 什么时候构造默认值？
2. 为了查一个已经存在的键，我会不会先为新键分配内存？

先看看这一行到底返回了什么。

or_insert 返回什么

我们先把代码拆成两行看看。

let count = counts.entry(path).or_insert(0);
*count += 1;

第一行的 count 保存的是可变引用，第二行再用星号解引用，修改它指向的值。

entry(path) 代表这个键在表里的条目。条目有两种状态，已存在（occupied）和空缺（vacant）。

or_insert(0) 会往空缺条目里填个零，已有的值则原样保留。

无论是哪种情况，它都会返回指向表内值的可变引用。这里的类型是 &mut usize。

所以第二行 *count += 1 直接改了表里的数字，改完也就不用再插一次了。

第一次遇到 /login，先插入零，再加到一。下一次遇到 /login，就从一加到二。两种情况下都会加一，所以初始值应该是零。

如果你不理解这个用法，写出下面这段代码，就有个很常见的小 bug。

*counts.entry(path).or_insert(1) += 1;

or_insert(1) 再加一，会导致每个 URL 的第一条请求都被算成两次。

最初的版本和 entry() 之间，还有个挺实用的写法。

if let Some(count) = counts.get_mut(path) {
    *count += 1;
} else {
    counts.insert(path, 1);
}

它也省了单独的存在性检查和 unwrap()，读起来简洁优雅。

只是对于这里的计数，entry() 一行就能搞定。

分组不存在呢

除了计数，拿 entry() 做分组也很厉害。

假设我收到了几个服务报的错，想按服务把错误消息收集起来。

use std::collections::HashMap;

fn main() {
    let errors = [
        ("payments", "timeout"),
        ("search", "connection refused"),
        ("payments", "invalid currency"),
    ];

    let mut grouped: HashMap<&str, Vec<&str>> = HashMap::new(); // 标注了类型

    for (service, message) in errors {
        grouped.entry(service).or_default().push(message);
    }
    assert_eq!(
        grouped["payments"],
        vec!["timeout", "invalid currency"]
    );
}

条目缺失时，or_default() 会调用值类型的 Default 实现。这里拿到的是一个空 Vec。接着通过返回的可变引用调用 push()，把消息加进去。

注意，这里我们给 HashMap 标注了实际的泛型类型，这很有用！

它告诉 Rust 每组是个 Vec<&str>，这样，当我使用 or_default 的时候，编译器就知道我要构造什么------一个空的 Vec。

按客户归类订单、按扩展名归类文件，或者按字段收集校验消息，都可以这么写。因为分组的代码基本一样。

这些例子用的是固定输入里的字符串切片。如果结果需要获得这些文本的所有权，可以选择 String 这样的拥有所有权的类型。entry() 不会改变原有的生命周期要求。

如果第一次得单独处理

假设有个需求，需要记录每条请求路由最长的响应耗时，我可以先存下第一次测量的耗时，后面遇到更慢的再更新。

use std::collections::HashMap;

fn main() {
    let samples = [
        ("/login", 42_u64),
        ("/products", 90),
        ("/login", 65),
        ("/login", 38),
    ];
    let mut slowest: HashMap<&str, u64> = HashMap::new();
    for (path, milliseconds) in samples {
        slowest
            .entry(path)
            .and_modify(|current| {
                *current = (*current).max(milliseconds);
            })
            .or_insert(milliseconds);
    }
    assert_eq!(slowest["/login"], 65);
}

这两个方法这么用正好拼成需求要的两条分支。entry() 返回的条目要么已存在，要么空缺：

• 空缺，也就是第一次遇到这条路由：and_modify() 会直接跳过，到达 or_insert() 时存入这次测得的耗时。
• 已存在，之前已经记过：and_modify() 执行闭包，把旧值和新样本里的较大者写回；轮到 or_insert() 时保留已有值，并返回它的可变引用。

拿 /login 举例子：第一次是空缺，存进 42；第二次遇到，闭包把 42 和 65 取较大者，更新成 65；第三次，38 比 65 小，闭包写完值没变。最后断言的 65 就是这么来的。

正因如此，逻辑分支天然被拆成两半，各由一个方法负责，互不重叠，所以此处也不需要自己写 if/else 了。

or_insert 的表达式什么时候执行

你可能没懂什么意思，看一个完整的例子：

use std::collections::HashMap;

fn build_message() -> String {
    println!("Building the default message");
    String::from("Please try again later")
}
fn main() {
    let mut messages = HashMap::new();
    messages.insert("timeout", String::from("Request timed out"));
    messages.entry("timeout").or_insert(build_message());
    assert_eq!(messages["timeout"], "Request timed out");
}

看完代码，我问个问题，build_message 会执行吗？

答案：会。很奇怪！messages 中的数据存在，但 build_message 中的 println! 依然执行。

这里的原因，是 Rust 会在调用 or_insert() 前先求值 build_message()。等方法拿到构造好的字符串，发现用不上，就把它丢掉了。

如果想把这一步推迟到真要用的时候，可以把函数本身传进去。

messages.entry("timeout").or_insert_with(build_message);

这样一来，只有条目缺失时，or_insert_with() 才会调用这个函数。构造默认值时如果需要用到局部变量，也可以传闭包。

如果是一个简单的默认值，例如数字零或者一个小的常量，提前求值没什么影响。

但换成一个会分配内存、写日志或做大量工作的函数，差别就出来了。别看方法名里有个 or，但参数并不会像 || 的右操作数那样短路。

键的构造也有成本

不过，我并不会任何时候都用 entry()。

还是统计 URL 出现次数。这次假设表的类型是 HashMap<String, usize>，也就是说，表里用 String 当作键保存 URL。

而每次收到的 path 是一个 &str，比如 "/login"。

问题来了，要调用 entry()，就得先把它变成 String：

*counts.entry(path.to_owned()).or_insert(0) += 1;

这里的 path.to_owned() 会创建一个新的 String，把 URL 文本复制进去。

问题是，即使表里已经有 "/login"，这一步也会执行。 我们原本只想把次数加一，却还是先创建了一个最后用不上的字符串。

上一节的 or_insert_with() 只能推迟默认值的构造，而这里的字符串在调用 entry() 之前就已经创建好了。

如果统计过程中遇到的大多是重复的 URL，可以先查一下：

if let Some(count) = counts.get_mut(path) {
    *count += 1;
} else {
    counts.insert(path.to_owned(), 1);
}

get_mut(path) 可以直接用 &str 查找，不需要先创建 String。

这样，表里已经有这个 URL 时，就直接把次数加一。只有第一次遇到它、需要插入记录时，才调用 to_owned()。

当然，这也有取舍。重复的 URL 可以省掉一次字符串创建，新的 URL 则需要先查找，再插入。 哪种更合适，要看重复的 URL 多不多。

如果手头已经有一个可以直接交给表保存的 String，不需要再复制，那就直接用 entry()，没必要为了这点保留分支。

现在，我们看看文章开头的请求计数。那个例子用的是 HashMap<&str, usize>，它的键是 &str，不需要转换成 String，所以可以这么写：

*counts.entry(path).or_insert(0) += 1;

错误分组则是这样：

grouped.entry(service).or_default().push(message);

总结

遇到"有就更新，没有就插入"的需求，可以先想想 entry()。计数时，用 or_insert(0) 取得可变引用后加一。分组时，用 or_default() 准备好空集合，再放入数据。

不过，代码写短了，也得留意哪些流程会在你意想不到的时候执行。例如 or_insert() 的参数会先求值，构造默认值比较费事时，可以用 or_insert_with() 按需创建。

选哪种写法，要结合手头的数据和实际需求，不能一味追求一种写法吃遍天下。