¿Cómo concateno cadenas?

¿Cómo concateno las siguientes combinaciones de tipos:

• str y str
• String y str
• String y String

Cuando concatena cadenas, necesita asignar memoria para almacenar el resultado. Lo más fácil para empezar es Stringy &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);
}

Aquí, tenemos una cadena propia que podemos mutar. Esto es eficiente ya que potencialmente nos permite reutilizar la asignación de memoria. Hay un caso similar para Stringy String, como &String se puede desreferenciar como&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);
}

Después de esto, another_owned_stringno se ha tocado (nota sin mutcalificador). Hay otra variante que consume el Stringpero no requiere que sea mutable. Esta es una implementación del Addrasgo que toma a Stringcomo el lado izquierdo y a &strcomo el lado derecho:

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

Tenga en cuenta que owned_stringya no se puede acceder después de la llamada a +.

¿Qué pasaría si quisiéramos producir una nueva cadena, dejando ambas sin tocar? La forma más simple es usar format!:

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

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

Tenga en cuenta que ambas variables de entrada son inmutables, por lo que sabemos que no se tocan. Si quisiéramos hacer lo mismo para cualquier combinación de String, podemos usar el hecho de que Stringtambién se puede formatear:

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

Sin embargo, no tienes que usar format!. Puede clonar una cadena y agregar la otra cadena a la nueva cadena:

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

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

Nota : toda la especificación de tipo que hice es redundante: el compilador puede inferir todos los tipos en juego aquí. ¡Los agregué simplemente para que sean claros para las personas nuevas en Rust, ya que espero que esta pregunta sea popular entre ese grupo!

Para concatenar múltiples cadenas en una sola cadena, separadas por otro carácter, hay un par de formas.

Lo mejor que he visto es usar el joinmétodo en una matriz:

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

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

Dependiendo de su caso de uso, también puede preferir más control:

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

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

He visto algunas formas más manuales, algunas evitando una o dos asignaciones aquí y allá. Para propósitos de legibilidad, encuentro que los dos anteriores son suficientes.

Creo que ese concatmétodo y +debería mencionarse aquí también:

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

y también hay concat!macro pero solo para literales:

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

Formas simples de concatenar cadenas en RUST

Hay varios métodos disponibles en RUST para concatenar cadenas

Primer método (usando concat!()):

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

La salida del código anterior es:

ab

Segundo método (usando push_str()y +operador):

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

La salida del código anterior es:

ab

a B C

Tercer método ( Using format!()):

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

La salida del código anterior es:

ab

échale un vistazo y experimenta con Rust Play Ground