Colecciones y cadenas en Rust

La colección (Collection) es una de las formas más comunes de almacenamiento de datos en las estructuras de datos, la biblioteca estándar de Rust proporciona una variedad de tipos de colección para ayudar a los desarrolladores a manejar operaciones de estructuras de datos.

Vector

El vector (Vector) es una estructura de datos que almacena múltiples valores en una única estructura de datos, esta estructura almacena valores del mismo tipo de manera lineal en la memoria.

El vector es una lista lineal, y su representación en Rust es Vec<T>.

El uso del vector es similar al de una lista (List), podemos crear un vector específico de tipo de esta manera:

let vector: Vec<i32>= Vec::new();　//　Crear un tipo de i32　la lista vacía
let vector = vec![10,　20,　40,　8];　　　　　//　Crear vector a través de array

Usamos operaciones de adición en lista a menudo, pero la adición y la operación push de pila son esencialmente lo mismo, por lo que el vector solo tiene el método push para agregar un solo elemento:

fn main() {
　　　　let mut vector = vec![10,　20,　40,　8];
　　　　vector.push(16);
　　　　vector.push(32);
　　　　vector.push(64);
　　　　println!("{:?}", vector);
}

Resultados de ejecución:

[10,　20,　40,　80,　160,　320,　64]

El método append se utiliza para concatenar un vector al final de otro vector:

fn main() {
　　　　let mut v1: Vec<i32>= vec![10,　20,　40,　8];
　　　　let mut v2: Vec<i32>= vec![160,　320,　64];
　　　　v1.append(&mut v2);
　　　　println!("{:?}", v1);
}

Resultados de ejecución:

[10,　20,　40,　80,　160,　320,　64]

El método get se utiliza para extraer valores del vector:

fn main() {
　　　　si es necesario cambiar el valor de la variable durante el proceso de recorrido:10,　20,　40,　8];
　　　　println!("{}", match v.get(0) {
　　　　　　　　Some(value) => value.to_string(),
　　　　　　　　None => "None".to_string()
　　　　});
}

Resultados de ejecución:

1

Dado que la longitud del vector no se puede inferir lógicamente, el método get no puede garantizar que siempre se obtenga un valor, por lo que el valor de retorno del método get es el enumerado de Option, que puede estar vacío.

Esta es una forma segura de obtener valores, pero es un poco complicado de escribir. Si puedes garantizar que el índice de extracción no se salga del rango de índices de extracción del vector, también puedes usar la sintaxis de extracción de array:

fn main() {
　　　　recorrer vector:10,　20,　40,　8];
　　　　1]
}

Resultados de ejecución:

2

Pero si intentamos obtener v[4] ，那么向量会返回错误。

], entonces el vector devolverá un error.

fn main() {
　　　　recorrer vector:10let mut v = vec![　320,　57];
　　　　let v = vec![
　　　　　　　　　　　　for i in &v {
　　　　}
}

Resultados de ejecución:

100
32
57

println!("{}", i);

fn main() {
　　　　si es necesario cambiar el valor de la variable durante el proceso de recorrido:10let mut v = vec![　320,　57];
　　　　,
　　　　　　　　*for i in &mut v {　+i　5=
　　　　}
}

0;

cadena-8 Clase de cadena (String) se ha utilizado mucho en este capítulo, por lo que muchos métodos ya son conocidos por el lector. Este capítulo presenta principalmente métodos de cadena y UTF

propiedades.

nueva cadena:

let string = String::new();

conversión de tipos básicos a cadena:　1.　　　　　　　　　//　let one =
entero a cadena　1let float =3.　　　　　//　.to_string();
número flotante a cadena　//　let slice = "slice".to_string();

corte de cadena de caracteres a cadena-8 contiene UTF

representación de cadenas de caracteres de caracteres:
let hello = String::from("السلام عليكم");
let hello = String::from("Dobrý den");
let hello = String::from("Hello");
let hello = String::from("שָׁלוֹם");
let hello = String::from("नमस्ते");
let hello = String::from("こんにちは");
let hello = String::from("안녕하세요");
let hello = String::from("你好");
let hello = String::from("Olá");
let hello = String::from("Здравствуйте");

let hello = String::from("Hola");

adición de cadenas:
let mut s = String::from("run");　//　s.push_str("oob");
agregar cortes de cadena de caracteres　　　　　　　//　s.push('!');

agregar caracteres + usar

let s1　unión de cadenas de caracteres:
let s2　= String::from("Hello, ");
let s3　= String::from("world!");1　+　&s2;

= s

let s1　= String::from("tic");
let s2　= String::from("tac");
let s3　= String::from("toe");
esta sintaxis también puede incluir cortes de cadena:1　+　"-"　+　&s2　+　"-"　+　&s3;

usar el macro format!

let s1　= String::from("tic");
let s2　= String::from("tac");
let s3　= String::from("toe");
let s = format!("{}-{}-{}", s1, s2, s3);

longitud de la cadena:

let s = "hello";
let len = s.len();

el valor de len aquí es 5.

let s = "你好";
let len = s.len();

el valor de len aquí es 6porque el chino es UTF-8 códigoado, cada carácter tiene 3 bytes, por lo que la longitud es6pero Rust admite UTF-8 objeto de carácter, por lo que si desea contar el número de caracteres, puede convertir primero la cadena en un conjunto de caracteres:

let s = "hello你好";
let len = s.chars().count();

el valor de len aquí es 7porque hay en total 7 la longitud de cada carácter. La velocidad de contar caracteres es mucho más lenta que la de contar la longitud.

recorrer la cadena:

fn main() {
　　　　let s = String::from("hello中文");
　　　　for c in s.chars() {
　　　　　　　　println!("{}", c);
　　　　}
}

Resultados de ejecución:

h
e
l
l
o
中
文

tomar un carácter individual de una cadena:

fn main() {
　　　　let s = String::from("EN中文");
　　　　let a = s.chars().nth(2);
　　　　println!("{:?}", a);
}

Resultados de ejecución:

Some('中')

Notala función nth es una manera de extraer un valor de un iterador, ¡no utilícela así en el bucle! Porque UTF-8 ¡la longitud de cada carácter no es necesariamente igual!

si desea cortar una subcadena de una cadena:

fn main() {
　　　　let s = String::from("EN中文");
　　　　let sub = &s[0..2];
　　　　println!("{}", sub);
}

Resultados de ejecución:

EN

pero tenga en cuenta que este uso puede descomponer un UTF-8 ¡pero tenga cuidado, ya que así podría romperse un UTF

fn main() {
　　　　let s = String::from("EN中文");
　　　　let sub = &s[0..3];
　　　　println!("{}", sub);
}

Resultados de ejecución:

la hebra 'main' se congeló en 'byte index　3　no es un límite de carácter; está dentro de '中' (bytes　2..5) del `EN中文`, src\libcore\str\mod.rs:2069:5　
nota: ejecutar con `RUST_BACKTRACE=`1variable de entorno para mostrar una traza de retroceso.

La tabla de mapeo

La tabla de mapeo (Map) existe en otros idiomas. La más comúnmente utilizada es la tabla de mapeo de valores clave y valores hash (Hash Map).

Crear una nueva tabla de mapeo de valores de hash: }}

use std::collections::HashMap;
fn main() {
　　　　let mut map = HashMap::new();
　　　　map.insert("color", "rojo");
　　　　map.insert("tamaño", ""10　m^2");
　　　　println!("{}", map.get("color").unwrap());
}

Nota：Aquí no se ha declarado el genericidad del hash table, porque Rust tiene un mecanismo de juicio de tipo automático.

Resultados de ejecución:

rojo

Los métodos insert y get son los dos métodos más utilizados de las tablas de mapeo.

Las tablas de mapeo admiten iteradores:

use std::collections::HashMap;
fn main() {
　　　　let mut map = HashMap::new();
　　　　map.insert("color", "rojo");
　　　　map.insert("tamaño", ""10　m^2");
　　　　for p in map.iter() {
　　　　　　　　println!("{:?}", p);
　　　　}
}

Resultados de ejecución:

("color", "rojo")　
("tamaño", ""10　m^2)

Los elementos de iteración son tuplas que representan pares clave-valor.

Las tablas de mapeo de Rust son estructuras de datos muy convenientes, ya que al agregar nuevos pares clave-valor con el método insert, si ya existe una clave相同的键，directamente se sobrescribe el valor correspondiente. Si desea "insertar de manera segura", es decir, realizar la acción de inserción solo cuando se confirme que no existe alguna clave, puede hacerlo así:

map.entry("color").or_insert("red");

Esta frase significa que si no hay un par de clave-valor con la clave "color", se agrega y se establece el valor en "red", de lo contrario, se omite.

Si ya se ha determinado que existe alguna clave y se desea modificar el valor correspondiente directamente, hay una manera más rápida:

use std::collections::HashMap;
fn main() {
　　　　let mut map = HashMap::new();
　　　　map.insert(1, "a");
　　　　
　　　　if let Some(x) = map.get_mut(&1) {
　　　　　　　　*x = "b";
　　　　}
}