Rust 集合与字符串

La collection (Collection) est la forme de stockage de données la plus courante dans les structures de données, la bibliothèque standard de Rust fournit une riche variété de types de collections pour aider les développeurs à gérer les opérations de structures de données.

Le vecteur

Le vecteur (Vector) est une structure de données unidimensionnelle qui contient plusieurs valeurs, cette structure stocke linéairement des valeurs du même type en mémoire.

Le vecteur est une liste linéaire, représentée en Rust sous la forme de Vec<T>.

L'utilisation du vecteur est similaire à celle de la liste (List), nous pouvons créer ainsi un vecteur de type spécifique :

let vector: Vec<i32>= Vec::new();　//　Création d'un type de vecteur32　un vecteur vide
let vector = vec![10,　20,　40,　8];　　　　　//　Création de vecteurs par l'intermédiaire d'un tableau

Nous utilisons souvent des opérations d'ajout dans les tableaux linéaires, mais l'ajout et l'opération push de la pile sont essentiellement les mêmes, donc le vecteur n'a qu'une méthode push pour ajouter un seul élément :

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

运行结果：

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

La méthode append est utilisée pour ajouter un vecteur à la fin d'un autre vecteur :

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

运行结果：

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

La méthode get est utilisée pour extraire la valeur d'un vecteur :

fn main() {
　　　　If you need to change the value of the variable during the traversal process:10,　20,　40,　8];
　　　　println!("{}", match v.get(0) {
　　　　　　　　Some(value) => value.to_string(),
　　　　　　　　None => "None".to_string()
　　　　});
}

运行结果：

1

Comme la longueur du vecteur ne peut pas être déduite logiquement, la méthode get ne peut pas garantir que la valeur sera récupérée, donc la valeur de retour de la méthode get est l'ensemble de l'enumeration Option, qui peut être vide.

C'est une méthode de récupération sécurisée, mais elle est un peu fastidieuse à écrire. Si vous pouvez garantir que l'index de récupération ne dépasse pas la plage d'indices du vecteur, vous pouvez également utiliser la syntaxe de récupération d'array :

fn main() {
　　　　Traverse the vector:10,　20,　40,　8];
　　　　println!("{}", v[1]);
}

运行结果：

2

Mais si nous essayons d'obtenir v[4] ，那么向量会返回错误。

], then the vector will return an error.

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

运行结果：

100
32
57

println!("{}", i);

fn main() {
　　　　If you need to change the value of the variable during the traversal process:10let mut v = vec![　320,　57];
　　　　,
　　　　　　　　*for i in &mut v {　+i　5=
　　　　}
}

0;

strings-8 The String class (String) has been used a lot so far, so many methods are well-known to the reader. This chapter mainly introduces the methods of strings and UTF

properties.

new string:

let string = String::new();

basic type conversion to string:　1.　　　　　　　　　//　let one =
integer to string　1let float =3.　　　　　//　.to_string();
floating point to string　//　let slice = "slice".to_string();

string slicing to string-8 contains UTF

character string:
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");

string appending:
s.push_str("oob");　//　append string slices
s.push('!');　　　　　　　//　append characters

Using + Concatenation of strings:

let s1　=
let s2　=
let s3　=1　+　&s2;

=

let s1　= String::from("tic");
let s2　= String::from("tac");
let s3　= String::from("toe");
this syntax can also include string slicing:1　+　"-"　+　&s2　+　"-"　+　&s3;

Utiliser le macro format!:

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

La longueur de la chaîne:

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

La valeur de len ici est 5。

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

La valeur de len ici est 6。 Parce que le chinois est UTF-8 编码é, chaque caractère a une longueur de 3 octets, donc la longueur est6。 Mais Rust prend en charge UTF-8 Les objets de caractères, donc si vous souhaitez compter le nombre de caractères, vous pouvez d'abord prendre la chaîne comme ensemble de caractères:

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

La valeur de len ici est 7， car il y a au total 7 La vitesse de comptage des caractères est beaucoup plus lente que la vitesse de comptage de la longueur.

Parcourir la chaîne:

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

运行结果：

h
e
l
l
o
中
文

Extraire un caractère unique de la chaîne:

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

运行结果：

Some('中')

注意：nth est une méthode pour extraire une valeur d'un itérateur, n'utilisez pas ainsi dans une boucle ! Parce que UTF-8 La longueur de chaque caractère n'est pas nécessairement égale !

Si vous souhaitez extraire une sous-chaine de chaîne:

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

运行结果：

EN

Mais notez que cette utilisation pourrait fragmenter un UTF-8 Soyez attentif, utiliser des caractères ! Cela会产生错误：

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

运行结果：

le fil d'exécution 'main' a paniqué à 'byte index　3　n'est pas une frontière de caractères; il est à l'intérieur de '中' (octets　2..5) du `EN中文`, src\libcore\str\mod.rs:2069:5　
note: exécuter avec `RUST_BACKTRACE=1`1variable d'environnement pour afficher un backtrace.

Les tableaux de correspondance

Les tableaux de correspondance (Map) existent largement dans d'autres langages. Celui qui est le plus couramment utilisé est la table de hachage de correspondance (Hash Map).

新建一个散列值映射表：

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

注意：这里没有声明散列表的泛型，是因为 Rust 的自动判断类型机制。

运行结果：

red

insert 方法和 get 方法是映射表最常用的两个方法。

映射表支持迭代器：

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

运行结果：

("color", "red")　
("size", ""10　m^2)

迭代元素是表示键值对的元组。

Rust 的映射表是十分方便的数据结构，当使用 insert 方法添加新的键值对的时候，如果已经存在相同的键，会直接覆盖对应的值。如果你想"安全地插入"，就是在确认当前不存在某个键时才执行的插入动作，可以这样：

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

这句话的意思是如果没有键为 "color" 的键值对就添加它并设定值为 "red"，否则将跳过。

在已经确定有某个键的情况下如果想直接修改对应的值，有更快的办法：

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