How to Join a Vec<String> into One String in Rust

By the end of this page, you will understand how to join multiple strings into one String in Rust, especially from a Vec<String> or string slices. You will learn the join() method, what types it works on, how separators are used, and common patterns developers use in real Rust code.

In Rust, joining strings means taking multiple string values and combining them into one larger String, with an optional separator placed between each item.

The most common tool for this is the join() method on slices of strings. In practice, this is often used with:

• Vec<String>
• Vec<&str>
• slices like &[String]
• collections that can be viewed as string slices

For example, if you have these values:

• "Foo"
• "Bar"
• "Baz"

and join them with "-", the result is:

Foo-Bar-Baz

This matters because combining text is very common in real programs:

• building file paths or labels
• generating CSV-like output
• constructing log messages
• formatting command-line output
• turning a list of values into a readable string

In Rust, string handling is explicit and type-safe. That means it is important to know whether you are working with:

• String — owned, growable string data

Think of join() like connecting train cars with a coupling placed between each car.

• Each string is a train car.
• The separator is the coupling, such as "-" or ", ".
• The final result is one complete train.

If your list is:

["Foo", "Bar", "Baz"]

and your separator is "-", then join() builds:

Foo-Bar-Baz

Important detail: the separator goes between items, not before the first item and not after the last item.

The basic Rust syntax is:

let joined = vec.join(separator);

Example with Vec<String>

fn main() {
    let string_list = vec!["Foo".to_string(), "Bar".to_string()];
    let joined = string_list.join("-");

    assert_eq!("Foo-Bar", joined);
}

Why this works

• string_list is a Vec<String>
• join("-") combines all elements
• "-" is inserted between each element
• the result is a new String

Example with Vec<&str>

Consider this example:

fn main() {
    let items = vec!["Foo".to_string(), "Bar".to_string(), "Baz".to_string()];
    let result = items.join("-");
    println!("{}", result);
}

Here is what happens step by step:

1. Rust creates a vector named items.
2. The vector contains three String values:
   • "Foo"
   • "Bar"
   • "Baz"
3. items.join("-") is called.
4. Rust starts building a new String for the result.
5. It adds the first item: "Foo"
6. It sees another item exists, so it adds the separator: "-"

Joining strings appears in many common Rust tasks.

Building command output

let args = vec!["cargo", "build", "--release"];
let command = args.join(" ");
// "cargo build --release"

Creating CSV-style text

let fields = vec!["Alice", "24", "Engineer"];
let line = fields.join(",");
// "Alice,24,Engineer"

Formatting tags or labels

let tags = vec!["rust", "strings", "beginner"];
let display = tags.join(" | ");
// "rust | strings | beginner"

Constructing paths or keys

In real Rust codebases, developers often use join() after transforming data into text.

Pattern: map values to strings, then join

fn main() {
    let numbers = vec![10, 20, 30];
    let output = numbers
        .iter()
        .map(|n| n.to_string())
        .collect::<Vec<_>>()
        .join(", ");

    assert_eq!("10, 20, 30", output);
}

This pattern is common when original values are not strings.

Pattern: validation before joining

fn join_names(names: Vec<String>) -> String {
    if names.is_empty() {
        return "No names".to_string();
    }

    names.join(", ")
}

1. Trying to call join as a free function

Broken idea:

let joined = something::join(string_list, "-");

Why it is wrong:

• In Rust, join is usually called as a method on the collection or slice.

Correct version:

let joined = string_list.join("-");

2. Forgetting that join() returns a new String

let parts = vec!["a".to_string(), "b".to_string()];
let result = parts.join("-");

result is a new owned . It does not modify each element in place.

vs

Quick syntax

let result = items.join(", ");

Works well with

• Vec<String>
• Vec<&str>
• slices of string-like values

Examples

let a = vec!["Foo".to_string(), "Bar".to_string()];
let b = a.join("-");
// "Foo-Bar"

let a = vec!["x", "y", "z"];
let b = a.join("");
// "xyz"

Use concat() when no separator is needed

How do I join a Vec<String> in Rust?

Use the join() method:

let items = vec!["Foo".to_string(), "Bar".to_string()];
let result = items.join("-");

Can I join a Vec<&str> too?

Yes.

let items = vec!["Foo", "Bar"];
let result = items.join("-");

What does join() return in Rust?

It returns a new owned String.

Does join() add the separator at the end?

No. The separator is only inserted between items.

What happens if the vector is empty?

String

Understanding owned strings helps you know what join() returns.

&str

String slices are commonly joined directly or mixed with String values.

format!

Useful when building custom strings instead of joining a list.

concat()

Related because it combines strings without a separator.

Iterators

Often you transform values with .map() before collecting and joining them.

collect()

Commonly used to turn iterator output into a Vec before calling join().

map()

Useful for converting non-string items into strings before joining.