Comment concaténer des chaînes?

Lorsque vous concaténer des chaînes, vous avez besoin d'allouer de la mémoire pour stocker le résultat. La méthode la plus simple pour commencer est String et &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);
}

Ici, nous avons une propriété de chaîne que l'on peut muter. C'est efficace, car elle permet potentiellement à réutiliser l'allocation de la mémoire. Il y a un cas similaire pour String et String, comme &String peut être déréférencé comme &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);
}

Après cela, another_owned_string est intacte (note n mut qualifier). Il y a une autre variante de consomme la String mais n'en a pas besoin pour être mutables. C'est un la mise en œuvre de la Ajouter trait de caractère qui prend un String que la gauche et un &str que le côté droit:

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);
}

Noter que owned_string n'est plus accessible suite à l'appel à +.

Que si nous voulions produire une nouvelle chaîne, en laissant intacte? La façon la plus simple est d'utiliser format!:

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

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

Noter que les deux variables d'entrée sont immuables, de sorte que nous savons qu'ils ne sont pas touché. Si nous voulions faire la même chose pour n'importe quelle combinaison de String, nous pouvons utiliser le fait que String peut également être mis en forme:

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);
}

Vous n'avez pas ont à utiliser format! bien. Vous pouvez cloner un string et ajouter l'autre de la chaîne de la nouvelle chaîne:

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

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

Note - ensemble de la spécification du type je ne l'ai est redondant - le compilateur peut déduire tous les types de jouer ici. J'ai ajouté, tout simplement, pour être clair pour les gens nouveaux à la Rouille, comme je m'attends à cette question pour être populaire avec le groupe!

Je pense que concat méthode et + doit être mentionné ici:

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

et il y a aussi concat! macro, mais seulement pour les littéraux:

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