如果您尝试显式显示隐式生存期，您将获得get_common_prefix的以下签名：

fn get_common_prefix<'a, 'b>(s1: &'a String, s2: &'b String) -> String { 
    ...
}

特别是，你不能交换这两个值，因为两个借款的持续时间都没有对方长。相反，你可以

fn get_common_prefix<'a>(s1: &'a String, s2: &'a String) -> String { 
    ...
}

这样做可以解决问题，但也会抛出许多其他错误，因为您的代码中还有其他问题。让我们一个一个地看。
首先，它现在会抱怨std::mem::swap(&mut s1, &mut s2);是非法的，因为

error[E0596]: cannot borrow `s1` as mutable, as it is not declared as mutable
 --> src/main.rs:4:24
  |
4 |         std::mem::swap(&mut s1, &mut s2);
  |                        ^^^^^^^ cannot borrow as mutable
  |
help: consider changing this to be mutable
  |
1 | pub fn get_common_prefix<'a>(mut s1: &'a String, s2: &'a String) -> String {
  |                              +++

error[E0596]: cannot borrow `s2` as mutable, as it is not declared as mutable
 --> src/main.rs:4:33
  |
4 |         std::mem::swap(&mut s1, &mut s2);
  |                                 ^^^^^^^ cannot borrow as mutable
  |
help: consider changing this to be mutable
  |
1 | pub fn get_common_prefix<'a>(s1: &'a String, mut s2: &'a String) -> String {
  |                                              +++

然而，Rust非常好，它告诉你在这种情况下该怎么做，将s1和s2都声明为可变的：

fn get_common_prefix<'a>(mut s1: &'a String, mut s2: &'a String) -> String { 
    ...
}

函数get_common_prefix现在是正确的，但是在longest_common_prefix中仍然有一个错误：

error[E0507]: cannot move out of index of `Vec<String>`
  --> src/main.rs:16:28
   |
16 |     let mut longest_pref = strs[0];
   |                            ^^^^^^^ move occurs because value has type `String`, which does not implement the `Copy` trait
   |
help: consider borrowing here
   |
16 |     let mut longest_pref = &strs[0];
   |                            +

问题是，您从strs中获取strs[0]，但没有删除它，这是非法的，因为第一个字符串现在将被拥有两次（一次由longest_pref拥有，一次由strs拥有）。
一种解决方案是实际使用strs[0]，其中swap_remove（这在从向量中删除元素时非常有效，假设我们不关心元素的顺序）：

pub fn longest_common_prefix(mut strs: Vec<String>) -> String {
    strs.sort();
    let mut longest_pref = strs.swap_remove(0);
    for i in 1..strs.len() {
        longest_pref = get_common_prefix(&longest_pref, &strs[i]);
    }
    return longest_pref;
}

这个可以但是。。这是非常低效的，有几个原因。首先，即使它不是一个可怕的性能损失，但在函数签名中包含&String几乎总是错误的，因为您只能使用它（实际上，Rust会为你做这件事，所以你可能没有意识到）是将Deref转换为&str，这基本上是相同的，少了一个间接（因为你可以看到String作为指向str的指针）。所以我们应该直接写出来

fn get_common_prefix<'a>(s1: &'a str, s2: &'a str) -> String { 
    ...
}

此外，返回String是没有意义的，因为它需要分配，当我们可以返回一个slice在该字符串上（因为我们取子字符串）：

pub fn get_common_prefix<'a>(mut s1: &'a str, mut s2: &'a str) -> &'a str {
    let mut idx: usize = 0;
    if s1.len() > s2.len() {
        std::mem::swap(&mut s1, &mut s2);
    }
    
    while idx < s1.len() && s1.chars().nth(idx) == s2.chars().nth(idx) {
        idx += 1;    
    }
    return &s1[0..idx]
}

• 请注意，我更改了返回类型和最后一行。*

现在，为了使其工作，我们还需要调整longest_common_prefix以使用字符串切片：

pub fn longest_common_prefix(mut strs: Vec<String>) -> String {
    strs.sort();
    let mut longest_pref: &str = &strs[0];
    for i in 1..strs.len() {
        longest_pref = get_common_prefix(&longest_pref, &strs[i]);
    }
    return longest_pref.to_string();
}

我们回到了strs的第一个元素，而不是 * 获取它。此外，我们只执行一次分配到String中，实际上我们必须返回String。
还有一些其他的优化工作要做。首先，排序strs是无用的，它不会改变longest_common_prefix的结果，所以我们可以删除它

pub fn longest_common_prefix(strs: Vec<String>) -> String {
    let mut longest_pref: &str = &strs[0];
    for i in 1..strs.len() {
        longest_pref = get_common_prefix(&longest_pref, &strs[i]);
    }
    return longest_pref.to_string();
}

接下来，s1.chars().nth(i)非常慢（Θ(i)）。一种更有效的方法是重用相同的迭代器（s1.chars()），并在每一步推进它，如下所示

for (c1, c2) in s1.chars().zip(s2.chars()) {
    if c1 != c2 {
        break;
    }
    idx += 1;    
}

.zip()不会从最长的字符串中取出任何剩余字符，因此我们实际上可以完全删除swap，得到

pub fn get_common_prefix<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    let mut idx: usize = 0;
    for (c1, c2) in s1.chars().zip(s2.chars()) {
        if c1 != c2 {
            break;
        }
        idx += c1.len_utf8();    
    }
    return &s1[0..idx]
}

注意：如@SebastianRedi所示，idx不应该增加1，而应该增加c1.len_utf8()，因为在索引字符串时，索引是以字节表示的，而不是以字符表示的，并且某些字符的长度超过一个字节。

作为对另一个答案的评论中的讨论的回应，下面是longest_common_prefix()的一个实现，它正确地使用了扩展的字素集群，并适用于字符串切片的任意迭代器：

use unicode_segmentation::UnicodeSegmentation;

pub fn longest_common_prefix<'a, I>(strings: I) -> &'a str
where
    I: IntoIterator<Item = &'a str>,
{
    let mut iters: Vec<_> = strings.into_iter().map(|s| s.graphemes(true)).collect();
    match iters.len() {
        0 => return "",
        1 => return iters[0].as_str(),
        _ => {}
    };
    let first = iters[0].as_str();
    let mut length = 0;
    loop {
        let Some(g) = iters[0].next() else { break; };
        if iters[1..].iter_mut().any(|iter| iter.next() != Some(g)) {
            break;
        }
        length += g.len();
    }
    &first[..length]
}

Unicode标准化仍然需要在此函数之外执行，例如就像这样：

use unicode_normalization::UnicodeNormalization;

let strings = ...; // the input strings
let normalized: Vec<String> = strings.iter().map(|s| s.nfc().collect()).collect();
let common_prefix = longest_common_prefix(normalized.iter().map(|s| s.as_str()));

上面的代码使用了这些依赖项：

unicode-segmentation = "1.10.1"
unicode-normalization = "0.1.22"