如果您正在寻找Python风格的分割，即对分割字符串的两端进行元组解包，则可以执行以下操作

if let Some((a, b)) = line.split_once(' ') {
    // ...
}

使用split()

let mut split = "some string 123 ffd".split("123");

这给出了一个迭代器，你可以循环使用它，或者将collect()转换成一个向量。

for s in split {
    println!("{}", s)
}
let vec = split.collect::<Vec<&str>>();
// OR
let vec: Vec<&str> = split.collect();

有三种简单的方法：
1.按分隔符：

s.split("separator")  |  s.split('/')  |  s.split(char::is_numeric)

1.按空格：

s.split_whitespace()

1.通过换行：

s.lines()

1.通过正则表达式：* （使用regex板条箱）*

Regex::new(r"\s").unwrap().split("one two three")

每种类型的结果都是一个迭代器：

let text = "foo\r\nbar\n\nbaz\n";
let mut lines = text.lines();

assert_eq!(Some("foo"), lines.next());
assert_eq!(Some("bar"), lines.next());
assert_eq!(Some(""), lines.next());
assert_eq!(Some("baz"), lines.next());

assert_eq!(None, lines.next());

结构String有一个特殊的方法split：

fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> where P: Pattern<'a>

按字符拆分：

let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

按字符串拆分：

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

按闭合拆分：

let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

split返回一个Iterator，可以使用collect将其转换为Vec：split_line.collect::<Vec<_>>()。通过迭代器而不是直接返回Vec有几个优点：

• split是懒惰的，这意味着它不会真正地拆分行，直到你需要它。这样，如果你只需要前几个值，它就不会浪费时间拆分整个字符串：split_line.take(2).collect::<Vec<_>>()，或者即使您只需要第一个可以转换为整数的值：最后一个例子不会浪费时间试图处理“23.0”，而是一旦发现“1”就立即停止处理。
• split对结果的存储方式没有任何假设。您可以使用Vec，但也可以使用任何实现FromIterator<&str>的类型，例如LinkedList或VecDeque，或者任何实现FromIterator<&str>的自定义类型。

还有split_whitespace()

fn main() {
    let words: Vec<&str> = "   foo   bar\t\nbaz   ".split_whitespace().collect();
    println!("{:?}", words);
    // ["foo", "bar", "baz"] 
}

OP的问题是如何拆分多字符串，这里有一种方法可以将part1和part2的结果作为String s，而不是在vector中。
此处使用非ASCII字符串"☄☃🤔"代替"123"进行拆分：

let s = "☄☃🤔";  // also works with non-ASCII characters
let mut part1 = "some string ☄☃🤔 ffd".to_string();
let _t;
let part2;
if let Some(idx) = part1.find(s) {
    part2 = part1.split_off(idx + s.len());
    _t = part1.split_off(idx);
}
else {
    part2 = "".to_string();
}

获取：part1 = "some string "
part2 = " ffd"
如果没有找到"☄☃🤔"，则part1包含未被触及的原始String，并且part2为空。
下面是罗塞塔代码中的一个很好的例子- * 根据字符的变化拆分字符串 * -说明如何使用split_off来转换一个简短的解决方案：

fn main() {
    let mut part1 = "gHHH5YY++///\\".to_string();
    if let Some(mut last) = part1.chars().next() {
        let mut pos = 0;
        while let Some(c) = part1.chars().find(|&c| {if c != last {true} else {pos += c.len_utf8(); false}}) {
            let part2 = part1.split_off(pos);
            print!("{}, ", part1);
            part1 = part2;
            last = c;
            pos = 0;
        }
    }
    println!("{}", part1);
}

变成那样

• 任务 *
• 根据字符变化（从左到右）将（字符）字符串拆分为逗号（加空格）分隔的字符串。*