一个 DRY 解决方案是使用peekable iterators：

pub fn print_comma_separated(elements: Vec<&str>)  {
    let mut it = elements.iter().peekable();
    loop {
        if let Some(x) = it.next() {
            print!("{x}"); // only one occurance of 'stringification'
        } else {
            break;
        }
        if it.peek().is_some() {
            print!(", ");
        }
    }
}

pub fn main() {
    print_comma_separated(vec!["a", "b", "c"]);
}

https://godbolt.org/z/zMaP5oExa

另一种itertools方法，通过使用intersperse避免了join中的字符串分配：

use itertools::Itertools;

pub fn print_comma_separated(elements: &Vec<&str>)  {
    for x in Itertools::intersperse(elements.iter().map(|x| Some(x)), None) {
        if let Some(x) = x {
            print!("{x}")
        } else {
            print!(", ")
        }
    }
}

pub fn main() {
    print_comma_separated(&vec!["a", "b", "c"]);
}

Demo
Rust nightly甚至将intersperse添加到std本身，这将更加出色。

你不需要一个布尔标志。你可以使用底层的迭代器，然后在抓取第一个元素后，将其余的元素传递给for循环（或者.map它以获得更多的函数式风格）：

pub fn foo(ls: &[&str]) -> Option<()> {
    // We get an iterator over the items in a slice
    let mut iter = ls.iter();

    // Get the first item. Note that it's
    // an Option, the slice may be empty.
    // If it is this will essentially
    // return early
    let first = iter.next()?;

    // Do something special with the first element
    println!("first: {first}");

    // Loop over the rest
    for item in iter {
        println!("item: {item}");
    }

    // Return an empty option to satisfy the
    // return type
    Some(())
}   

fn main() {
    foo(&vec!["a", "b", "c"]);
}

你可以看到playground没有解释性注解，它非常简洁。

创建另一个函数是最简单的方法。

fn print_split_last(items: &[&str]) {
    if let Some((last, elems)) = items.split_last() {
        for elem in elems {
            let formatted_value = elem_to_string(elem);
            print!("{formatted_value}, ");
        }
        let formatted_value = elem_to_string(last);
        print!("{formatted_value}");
    }
}

fn elem_to_string(elem: &str) -> String {
    elem.to_string()
}

如果涉及到很多状态，可以将其设为闭包并捕获状态。

fn print_split_last(items: &[&str]) {
    let mut state = 0;
    let elem_to_string = |elem| elem.with_state(&mut state);
    if let Some((last, elems)) = items.split_last() {
        for elem in elems {
            let formatted_value = elem_to_string(elem);
            print!("{formatted_value}, ");
        }
        let formatted_value = elem_to_string(last);
        print!("{formatted_value}");
    }
}

你甚至可以把闭包作为一个参数。为了避免创建临时字符串，您应该转换为实现Display的类型。

use std::fmt::Display;

fn print_split_last<T, F, D>(items: &[T], mut f: F)
where
    F: FnMut(&T) -> D,
    D: Display,
{
    if let Some((last, elems)) = items.split_last() {
        for elem in elems {
            let formatted_value = f(elem);
            print!("{formatted_value}, ");
        }
        let formatted_value = f(last);
        print!("{formatted_value}");
    }
}

使用Itertools或不介意依赖关系的人有itertools::join：

use itertools::join;

fn main() {
    println!("{}", join(vec!["a", "b", "c"], ", "))
}

Demo
或更多定制：

use itertools::join;

fn main() {
    let list = vec!["a", "b", "c"];
    println!("{}", join(list.iter().map(|x| {
        format!("{x}") //whatever formatting is desired
    }), ", "))
}

Demo

最简单的，不使用板条箱的方法是：

pub fn print_comma_separated(elements: Vec<&str>)  {
    let mut it = elements.iter();
    let Some(first) = it.next() else {
        return
    }
    print!("{first}");
    for x in it {
        print!(", {x}")
    }
}

很清楚如何将其扩展到,以外的分隔符。