Strings

Un String es una colección/secuencia de chars (valores escalares) codificados en Unicode (en concreto UTF-8 de 1-4 bytes, siguiendo las reglas Unicode, porque es compatible con ASCII), y Rust se encarga de que sea UTF-8 válido.

Los Strings no están terminados en un carácter nulo (\0), ya que pueden contener estos caracteres.

Los Strings pueden ser representados como bytes (&[u8]), escalares (char, un carácter separado y único de Unicode) o grapheme clusters (lo que nosotros llamamos letras):

• bytes(): devuelve un iterador del String como bytes
• chars(): devuelve un iterador del String como char
• unicode_segmentation::UnicodeSegmentation::graphemes("...", true /*is_extended*/): unicode-segmentation (crate) to graphemes

Por norma general, a no ser que estemos trabajando con lenguas con una escritura compleja, los chars coinciden con nuestras letras:

1こんにちは:
2bytes: [227, 129, 147, 227, 130, 147, 227, 129, 171, 227, 129, 161, 227, 129, 175] (15)
3chars: [こ, ん, に, ち, は] (5)
4graphemes: [こ, ん, に, ち, は] (5)
5
6नमस्ते:
7bytes: [224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164, 224, 165, 135] (18)
8chars: [न, म, स, \u{94d}, त, \u{947}] (6)
9graphemes: [न, म, स\u{94d}, त\u{947}] (4)

Formas de crear un String:

1let s1 = String::new();
2let s2 = "".to_string();
3let s3 = String::from("");

Con String Slices simplemente entre comillas ".

Algunos métodos para añadir al String:

1s.push('c');       // Se añade un nuevo caracter
2s.push_str("str"); // Se añade un String Slice
3s = &s1 + &s2;
4s += " mundo";
5s = format!("{}{}", s1, s2);

String Slices

Se trata de un slice de un String: &str.

1let s = String::from("Hello World");
2let hello = &s[0..5];  // also [..5]
3let world = &s[6..11]; // also [6..]
4let hello_world = &s[..]

Aquí estamos creando una referencia a un trozo del String, no al String entero:

El tipo de dato de un String slice se escribe &str, y si declaramos un String literal de la siguiente forma, también será de tipo &str:

1let s = "Hello World";

Un detalle a tener en cuenta, es que podemos convertir Strings de forma muy sencilla a &str, por lo que los hace el tipo ideal para usar como parámetros en funciones:

1fn foo(s: &str) {}
2let s1 = String::from("Hello World");
3let s2 = "Hello World again";
4
5foo(&s1[..]); // or s1.as_str()
6foo(s2);

String literals

Estos son los Strings que existen hard coded dentro del programa, por lo que están guardados dentro del propio programa, lo cual lo hace su dueño. Esto quiere decir que estas valdrán hasta el final del programa, como su dueño (&'static str).

Estas son algunas formas de representarlas:

Para evitar que al separar los Strings, se añadan saltos de línea (\n) se puede hacer lo siguiente:

1let s = "hola\
2        que tal\
3        como estas?";

Además de eso, se ignoran los espacios antes del primer carácter. Output:

1holaque talcomo estas?

Podemos entonces hacer el siguiente hack, para quitar los espacios iniciales pero manteniendo los saltos de línea:

1let s = "hola\n\
2        que tal\n\
3        como estas?";

Output:

1hola
2que tal
3como estas?

La otra opción es la siguiente:

1let s = r###"
2    hola
3    que tal estas?
4    me alegro que estes bien"###;

En este caso, lo que aparezca literalmente entre los ###" "###, tanto ", espacios y otros caracteres.