Як з'єднати рядки?

Як об'єднати такі комбінації типів:

• str і str
• String і str
• String і String

Коли ви об'єднуєте рядки, вам потрібно виділити пам'ять для зберігання результату. Простіше за все почати з 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 , але не вимагає від нього бути змінними. Це реалізація Addознаки, яка приймає Stringяк ліву, &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);
}

Примітка - вся специфікація типу, яку я зробив, є зайвою - компілятор може зробити висновок про всі типи, які тут відтворюються. Я додав їх просто для того, щоб зрозуміти людям, які не знайомі з Рустом, оскільки очікую, що це питання буде популярним у цій групі!

Для об'єднання декількох рядків в один рядок, розділених іншим символом, існує кілька способів.

Найприємніше, що я бачив - це використання 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);
}

Я бачив ще кілька ручних способів, які уникають одного або двох виділень тут і там. Для читання я вважаю, що зазначені вище два є достатніми.

Я думаю, що цей concatметод і тут +слід згадати:

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

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

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

Прості способи об'єднання рядків у RUST

У RUST доступні різні методи об'єднання рядків

Перший метод (використання concat!()):

fn main() {
    println!("{}", concat!("a", "b"))
}

Вихід з вищевказаного коду:

аб

Другий метод (з використанням push_str()та +оператора):

fn main() {
    let mut _a = "a".to_string();
    let _b = "b".to_string();
    let _c = "c".to_string();

    _a.push_str(&_b);
    
    println!("{}", _a);
 
    println!("{}", _a + &_b);
}

Вихід з вищевказаного коду:

аб

абс

Третій метод ( Using format!()):

fn main() {
    let mut _a = "a".to_string();
    let _b = "b".to_string();
    let _c = format!("{}{}", _a, _b);
    
    println!("{}", _c);
}

Вихід з вищевказаного коду:

аб

перевірити це та поекспериментувати з ігровим майданчиком Rust