string - numeros - ¿Cómo concateno cadenas?

string concat java

Question

¿Cómo concateno las siguientes combinaciones de tipos:

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

Answer 1

Creo que el método concat y + deberían mencionarse aquí:

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

Answer 2

Cuando concatena cadenas, debe asignar memoria para almacenar el resultado. Lo más fácil para comenzar es String y &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 String y String , ya que &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_string queda intacta (tenga en cuenta que no hay calificador mut ). Hay otra variante que consume la String pero no requiere que sea mutable. Esta es una implementación del rasgo Add que toma una String como el lado izquierdo y un &str como 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_string ya no es accesible 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 el 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 String también puede formatearse:

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

¡No tienes que usar el format! aunque. 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!

Answer 3

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 método de join 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.