Collections et chaînes de caractères en Rust

Les collections sont la forme la plus courante de stockage de données dans les structures de données. La bibliothèque standard Rust fournit un riche ensemble de types de collections pour aider les développeurs à gérer les opérations sur les structures de données.

Vecteur

Un vecteur est une structure de données unique qui stocke plusieurs valeurs, et il stocke des valeurs du même type de manière linéaire en mémoire.

Un vecteur est une liste linéaire, représenté par Vec<T> en Rust.

Les vecteurs sont utilisés de manière similaire aux listes. Nous pouvons créer un vecteur d'un type spécifié de cette façon :

let vector: Vec<i32> = Vec::new(); // 创建类型为 i32 的空向量
let vector = vec![1, 2, 4, 8];     // 通过数组创建向量

Lors de l'utilisation de listes linéaires, nous devons souvent effectuer des opérations d'ajout. Cependant, l'ajout est essentiellement identique à l'opération push d'une pile, donc les vecteurs n'ont que la méthode push pour ajouter un seul élément :

, le vecteur renverra une erreur.

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

Sortie :

[1, 2, 4, 8, 16, 32, 64]

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

Exemple

fn main() {
    let mut v1: Vec<i32> = vec![1, 2, 4, 8];
    let mut v2: Vec<i32> = vec![16, 32, 64];
    v1.append(&mut v2);
    println!("{:?}", v1);
}

Sortie :

[1, 2, 4, 8, 16, 32, 64]

La méthode get est utilisée pour récupérer une valeur à partir d'un vecteur :

Exemple

fn main() {
    let mut v = vec![1, 2, 4, 8];
    println!("{}", match v.get(0) {
        Some(value) => value.to_string(),
        None => "None".to_string()
    });
}

Sortie :

1

Comme la longueur d'un vecteur ne peut pas être déduite logiquement, la méthode get ne peut pas garantir qu'une valeur sera renvoyée, donc le type de retour de la méthode get est l'énumération Option, qui peut être None.

C'est une manière sûre d'obtenir une valeur, mais c'est un peu fastidieux à écrire. Si vous pouvez garantir que l'indice est dans la plage valide du vecteur, vous pouvez également utiliser la syntaxe d'indexation de tableau :

Exemple

fn main() {
    let v = vec![1, 2, 4, 8];
    println!("{}", v[1]);
}

Sortie :

2

Mais si nous essayons d'accéder à v

Itération sur un vecteur :

Exemple

fn main() {
    let v = vec![100, 32, 57];
    for i in &v {
            println!("{}", i);
    }
}

Sortie :

100
32
57

Si vous devez modifier la valeur d'une variable pendant l'itération :

Exemple

fn main() {
    let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
    }
}

String

Le type String a été utilisé de manière extensive jusqu'à ce chapitre, de sorte que beaucoup de ses méthodes sont déjà familières aux lecteurs. Ce chapitre présente principalement les méthodes de chaîne et les caractéristiques d'UTF-8.

Création d'une nouvelle chaîne :

let string = String::new();

Conversion de types de base en chaînes :

let one = 1.to_string();         // 整数到字符串
let float = 1.3.to_string();     // 浮点数到字符串
let slice = "slice".to_string(); // 字符串切片到字符串

Chaînes contenant des caractères UTF-8 :

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

Ajout à une chaîne :

let mut s = String::from("run");
s.push_str("oob"); // 追加字符串切片
s.push('!');       // 追加字符

Concaténation de chaînes avec le signe + :

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2;

Cette syntaxe peut également inclure des tranches de chaîne :

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");

let s = s1 + "-" + &s2 + "-" + &s3;

Utilisation de la macro format! :

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");

let s = format!("{}-{}-{}", s1, s2, s3);

Longueur de la chaîne :

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

Ici, la valeur de len est 5.

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

Ici, la valeur de len est 6. Parce que le chinois est encodé en UTF-8, chaque caractère fait 3 octets, donc la longueur est 6. Cependant, Rust prend en charge les objets caractères UTF-8, donc si vous voulez compter le nombre de caractères, vous pouvez d'abord convertir la chaîne en une collection de caractères :

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

Ici, la valeur de len est 7, car il y a 7 caractères au total. Compter les caractères est beaucoup plus lent que d'obtenir la longueur en octets.

Itérer sur une chaîne :

Exemple

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

Sortie :

h
e
l
l
o
中
文

Obtenir un seul caractère à partir d'une chaîne :

Exemple

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

Sortie :

Some('中')

Remarque: La fonction nth est une méthode pour récupérer une valeur à partir d'un itérateur. Veuillez ne pas l'utiliser de cette façon pendant l'itération ! Car la longueur de chaque caractère en UTF-8 n'est pas nécessairement égale !

Si vous souhaitez extraire une sous-chaîne d'une chaîne :

Exemple

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

Sortie :

EN

Mais notez que cette utilisation peut scinder un caractère UTF-8 ! Cela provoquera une erreur :

Exemple

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

Sortie :

thread 'main' panicked at 'byte index 3 is not a char boundary; it is inside '中' (bytes 2..5) of `EN中文`', src\libcore\str\mod.rs:2069:5 
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

Map

Les tables associatives sont très répandues dans d'autres langages. La plus couramment utilisée est la table de hachage clé-valeur.

Création d'une nouvelle table de hachage :

Exemple

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

Remarque: La raison pour laquelle nous n'avons pas déclaré le type générique de la table de hachage est due au mécanisme d'inférence de type automatique de Rust.

Sortie :

red

Les méthodes insert et get sont les deux méthodes les plus couramment utilisées d'une table associative.

Les tables associatives prennent en charge les itérateurs :

Exemple

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

Sortie :

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

Les éléments itérés sont des tuples représentant des paires clé-valeur.

La map de Rust est une structure de données très pratique. Lorsque vous utilisez la méthode insert pour ajouter une nouvelle paire clé-valeur, si la même clé existe déjà, elle écrasera directement la valeur correspondante. Si vous voulez « insérer en toute sécurité », c'est-à-dire n'exécuter l'insertion qu'après avoir confirmé qu'une clé n'existe pas actuellement, vous pouvez faire ceci :

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

Cela signifie : s'il n'existe aucune paire clé-valeur avec la clé "color", ajoutez-la et définissez la valeur sur "red" ; sinon, elle sera ignorée.

Si vous avez confirmé qu'une clé existe et que vous voulez modifier directement sa valeur correspondante, il existe un moyen plus rapide :

Exemple

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