在Rust中，有什么惯用的方法来打印所有命令行参数？

fn main() {
    let mut args = std::env::args();
    if let Some(arg) = args.next() {
        print!("{}", arg);
        for arg in args {
            print!(" {}", arg);
        }
    }
}

或者使用Itertools的format或format_with更好：

use itertools::Itertools; // 0.8.0
fn main() {
    println!("{}", std::env::args().format(" "));
}

我只想要一个空格隔开String

fn args() -> String {
    let mut result = String::new();
    let mut args = std::env::args();
    if let Some(arg) = args.next() {
        result.push_str(&arg);
        for arg in args {
            result.push(' ');
            result.push_str(&arg);
        }
    }
    result
}
fn main() {
    println!("{}", args());
}

或

fn args() -> String {
    let mut result = std::env::args().fold(String::new(), |s, arg| s + &arg + " ");
    result.pop();
    result
}
fn main() {
    println!("{}", args());
}

如果你使用Itertools，你可以使用上面的format/format_with例子和format!宏。
join也很有用：

use itertools::Itertools; // 0.8.0
fn args() -> String {
    std::env::args().join(" ")
}
fn main() {
    println!("{}", args());
}

在其他情况下，您可能需要使用intersperse：

use itertools::Itertools; // 0.8.0
fn args() -> String {
    std::env::args().intersperse(" ".to_string()).collect()
}
fn main() {
    println!("{}", args());
}

请注意，这不如其他选择有效，因为每次迭代都要克隆String。

这里有一个使用迭代器的解决方案，并且不依赖于stdlib
（性能方面，这在发布模式下大放异彩，优化打开[ playground ]）

use std::iter::once;
fn join_iter<T>(
    mut iter: impl Iterator<Item = T>,
    sep: impl Fn(&T) -> T,
) -> impl Iterator<Item = T> {
    iter.next()
        .into_iter()
        .chain(iter.flat_map(move |s| once(sep(&s)).chain(once(s))))
}
fn examples() {
    let iter = [1, 3, 5, 7, 9].iter().cloned();
    println!("{:?}", join_iter(iter, |v| v - 1).collect::<Vec<_>>());
    // [1, 2, 3, 4, 5, 6, 7, 8, 9]
    let iter = ["Hello", "World"].iter().cloned();
    let sep = ", ";
    println!("{:?}", join_iter(iter, |_| sep).collect::<String>());
    // "Hello, World"
}
fn args() -> String {
    join_iter(std::env::args(), |_| " ".to_string()).collect()
}
fn main() {
    examples();
    println!("{}", args());
}

这里有一个替代方案，
我只是想要一个空间分隔String的参数变量从std::env::args()获得

fn args_string() -> String {
    let mut out = String::new();
    let mut sep = "";
    for arg in std::env::args() {
        out.push_str(sep);
        out.push_str(&*arg);
        sep = " ";
    }
    out
}
pub fn main() {
    println!("{}", args_string());
}

下面是使用fold的版本

fn join<I, T, D>(iter: I, separator: D) -> String
where
    T: Display,
    D: Display,
    I: Iterator<Item = T>,
{
    match iter.fold(None, |a:Option<String>, b| {
        Some(match a {
            None => format!("{}", &b),
            Some(mut a) => {
                write!(a, "{}{}", separator, b).unwrap();
                a
            }
        })
    }) {
        None => String::new(),
        Some(rval) => rval,
    }
}

fn main() {
    println!("{}", std::env::args().collect::<Vec<_>>().join(" "));
}