Как объединить строки?

Ответ 1

Когда вы объединяете строки, вам нужно выделить память для хранения результата. Проще всего начать с String и &str:

fn main() {
    let mut owned_string: String = "hello ".to_owned();
    let borrowed_string: &str = "world";

    owned_string.push_str(borrowed_string);
    println!("{}", owned_string);
}

Здесь у нас есть собственная строка, которую мы можем изменить. Это эффективно, поскольку потенциально позволяет нам повторно использовать выделение памяти. Существует аналогичный случай для String и String, так как &String может быть разыменовано как &str.

fn main() {
    let mut owned_string: String = "hello ".to_owned();
    let another_owned_string: String = "world".to_owned();

    owned_string.push_str(&another_owned_string);
    println!("{}", owned_string);
}

После этого another_owned_string остается нетронутым (обратите внимание, что нет mut). Есть другой вариант, который потребляет String но не требует, чтобы она была изменяемой. Это rel=noreferrer>реализация черты Add которая принимает String в качестве левой стороны и a &str в качестве правой стороны:

fn main() {
    let owned_string: String = "hello ".to_owned();
    let borrowed_string: &str = "world";

    let new_owned_string = owned_string + borrowed_string;
    println!("{}", new_owned_string);
}

Обратите внимание, что owned_string больше не доступен после вызова +.

Что, если мы хотим создать новую строку, оставив обе нетронутыми? Самый простой способ - использовать format! :

fn main() {
    let borrowed_string: &str = "hello ";
    let another_borrowed_string: &str = "world";

    let together = format!("{}{}", borrowed_string, another_borrowed_string);
    println!("{}", together);
}

Обратите внимание, что обе входные переменные являются неизменяемыми, поэтому мы знаем, что они не затрагиваются. Если мы хотим сделать то же самое для любой комбинации String, мы можем использовать тот факт, что String также может быть отформатирован:

fn main() {
    let owned_string: String = "hello ".to_owned();
    let another_owned_string: String = "world".to_owned();

    let together = format!("{}{}", owned_string, another_owned_string);
    println!("{}", together);
}

Вам не нужно использовать format! хоть. Вы можете клонировать одну строку и добавить другую строку к новой строке:

fn main() {
    let owned_string: String = "hello ".to_owned();
    let borrowed_string: &str = "world";

    let together = owned_string.clone() + borrowed_string;
    println!("{}", together);
}

Обратите внимание - все спецификации типов, которые я сделал, являются избыточными - компилятор может вывести здесь все типы в игре. Я добавил их просто, чтобы они были понятны новичкам в Rust, так как я ожидаю, что этот вопрос будет популярен в этой группе!

Ответ 2

Чтобы объединить несколько строк в одну строку, разделенные другим символом, существует несколько способов.

Самое приятное, что я видел, это использовать метод join для массива:

fn main() {
    let a = "Hello";
    let b = "world";
    let result = [a, b].join("\n");

    print!("{}", result);
}

В зависимости от вашего варианта использования вы также можете больше контролировать:

fn main() {
    let a = "Hello";
    let b = "world";
    let result = format!("{}\n{}", a, b);

    print!("{}", result);
}

Есть несколько ручных способов, которые я видел, некоторые избегают одного или двух распределений здесь и там. Для удобства чтения я считаю, что указанные выше два являются достаточными.

Ответ 3

Я думаю, что метод concat и + должны быть упомянуты здесь:

assert_eq!(
  ("My".to_owned() + " " + "string"),
  ["My", " ", "string"].concat()
);

и есть также concat! макрос, но только для литералов:

let s = concat!("test", 10, 'b', true);
assert_eq!(s, "test10btrue");