Как правильно объединять строки в Rust: полное руководство для новичков

Основные способы объединения строк в Rust

В Rust действительно есть несколько способов объединить строки, и выбор зависит от контекста. Главное, что нужно понять — это разница между String (владеющая строка, динамическая, изменяемая) и &str (строковый срез, заимствованная ссылка). Оператор + работает только с String слева и &str справа.

1. Использование макроса format!

Самый универсальный и безопасный способ — макрос format!. Он работает с любыми типами, реализующими трейт Display:

fn main() {
    let hello = "Hello";
    let world = "world";
    let message = format!("{} {}", hello, world);
    println!("{}", message); // Выведет: Hello world

    // Работает и с String, и с &str
    let name = String::from("Alice");
    let greeting = format!("Привет, {}!", name);
    println!("{}", greeting); // Привет, Alice!
}

Плюсы: удобно, читаемо, подходит для сложных шаблонов.

2. Метод push_str и оператор +=

Если у вас уже есть String и вы хотите добавить к нему другие строки, используйте push_str или оператор +=:

fn main() {
    let mut result = String::from("Hello");
    result.push_str(" ");
    result.push_str("world");
    println!("{}", result); // Hello world

    // Эквивалентно через +=
    let mut result2 = String::from("Hello");
    result2 += " ";
    result2 += "world";
    println!("{}", result2); // Hello world
}

Плюсы: эффективно (нет лишних аллокаций), подходит для накопления строк.

3. Оператор +

Оператор + можно использовать, но с ограничениями: левый операнд должен быть String, правый — &str. Он потребляет левую строку (перемещает её), поэтому после использования исходная строка становится недоступной:

fn main() {
    let hello = String::from("Hello");
    let world = "world";
    let message = hello + " " + world; // hello перемещается
    println!("{}", message); // Hello world
    // println!("{}", hello); // Ошибка! hello уже перемещена
}

4. Метод concat и join для срезов

Если у вас есть коллекция строк, удобно использовать методы concat и join:

fn main() {
    let words = ["Hello", "world", "from", "Rust"];
    let sentence = words.concat();
    println!("{}", sentence); // HelloworldfromRust

    let sentence_with_space = words.join(" ");
    println!("{}", sentence_with_space); // Hello world from Rust
}

5. Сборка через collect с итераторами

Для цепочек преобразований можно комбинировать итераторы:

fn main() {
    let words = vec!["Hello", "world"];
    let message: String = words.iter()
        .map(|w| w.to_uppercase())
        .collect::>()
        .join(" ");
    println!("{}", message); // HELLO WORLD
}

Когда что использовать?

• format! — для простого форматирования с переменными (рекомендуется в 80% случаев)
• push_str / += — когда нужно добавить много частей к уже существующей строке
• + — только когда точно знаете, что левая строка больше не нужна
• join — для объединения массива/вектора строк с разделителем
• concat — для простого склеивания без разделителя

Главное правило: не пытайтесь складывать &str с &str через + — это не сработает. Используйте format! или преобразуйте один из операндов в String.

use std::borrow::Cow;

fn combine(a: &str, b: &str) -> Cow<str> {
    if a.is_empty() {
        Cow::Borrowed(b)
    } else if b.is_empty() {
        Cow::Borrowed(a)
    } else {
        let mut result = String::with_capacity(a.len() + b.len() + 1);
        result.push_str(a);
        result.push(' ');
        result.push_str(b);
        Cow::Owned(result)
    }
}

fn main() {
    let result = combine("Hello", "world");
    println!("{}", result);
}

fn build_string(parts: &[&str]) -> String {
    let total_len: usize = parts.iter().map(|s| s.len()).sum();
    let mut result = String::with_capacity(total_len + parts.len() - 1);
    for (i, part) in parts.iter().enumerate() {
        if i > 0 {
            result.push(' ');
        }
        result.push_str(part);
    }
    result
}