¿Cómo concateno cadenas?

Question

¿Cómo concateno cadenas?

Cómo concateno las siguientes combinaciones de tipos:

str y str
String y str
String y String

84

string string-concatenation rust

Author: malbarbo, 2015-05-10

Source

2 answers

Para concatenar varias cadenas en una sola cadena, separadas por otro carácter, hay un par de maneras.

Lo mejor que he visto es usar el método 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);
}

Hay algunas maneras más manuales que he visto, algunas evitando una o dos asignaciones aquí y allá. Para fines de legibilidad, encuentro que los dos anteriores son suficientes.

25

Author: Simon Whitehead,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/ajaxhispano.com/template/agent.layouts/content.php on line 61
2017-01-17 03:15:24

score 100 · Accepted Answer

Cuando concatena cadenas, necesita asignar memoria para almacenar el resultado. La forma más fácil de empezar 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, como &String puede ser desreferenciado 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 está intacto (nota no calificador mut). Hay otra variante que consume el String pero no requiere que sea mutable. Esta es una implementación del rasgo Add que toma a String como el lado izquierdo y a &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 +.

¿Y si quisiéramos producir una nueva cadena, dejando ambas intactas? La forma más sencilla es utilizar 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 son tocados. Si queremos hacer lo mismo para cualquier combinación de String, podemos usar el hecho de que String tambié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);
}

No tienes para usar format!. Puedes clonar una cadena y anexar 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 ser claros con las personas nuevas en Rust, ya que ¡espera que esta pregunta sea popular entre ese grupo!