How to format multiple lines using interpolation in Rust

As a Rust developer, you often find yourself working with strings, and there are various ways to format and manipulate them. In this article, we'll explore how to format multiline strings with interpolation in Rust. This technique allows you to embed variables or expressions within multiline strings for dynamic content.

Multiline Strings in Rust

Rust supports multiline strings using raw string literals. These literals are prefixed with r#" and can span multiple lines without the need for escape characters. Here's a quick example:

fn main() {
    let multiline_string = r#"
        This is a
        multiline
        string in Rust.
    "#;
 
    println!("{}", multiline_string);
}

The output of this program will be:

        This is a
        multiline
        string in Rust.

Interpolating Variables

Now, let's move on to the main focus of this article—interpolating variables or expressions within multiline strings. Rust provides a convenient way to achieve this using the curly braces {} as placeholders for values to be interpolated.

Example 1: Basic Variable Interpolation

fn main() {
    let name = "John";
    let age = 30;
 
    let formatted_string = format!(
        r#"
        Hello, my name is {}.
        I am {} years old.
    "#,
        name, age
    );
 
    println!("{}", formatted_string);
}

Output:

        Hello, my name is John.
        I am 30 years old.

Example 2: Expression Interpolation

You can also interpolate expressions within multiline strings. Here's an example where we calculate the square of a number:

fn main() {
    let number = 5;
 
    let formatted_string = format!(
        r#"
        The square of {} is {}.
    "#,
        number, number * number
    );
 
    println!("{}", formatted_string);
}

Output:

        The square of 5 is 25.

Conclusion

Formatting multiline strings with interpolation in Rust is a powerful feature that allows you to create more dynamic and readable code. By combining raw string literals with placeholders, you can easily embed variables and expressions within your multiline strings. This technique is particularly useful in situations where you need to generate complex string outputs, such as logging or generating dynamic documentation.

Experiment with these examples, and integrate multiline string interpolation into your Rust projects to enhance code clarity and maintainability.