Les chaînes de caractères en Rust

1. Quelques définitions

Unicode est un standard logiciel qui permet d’encoder n’importe quel caractère issu de toutes les langues du monde.

UTF-8 (Universal Character Set Transformation Format - 8 bits) est un codage de caractères conçu pour encoder l’ensemble des caractères du répertoire universel. UTF-8 est totalement compatible avec le standard Unicode.

2. Encodage en Rust

&str 
 
&'static str 

1. Nature des caractères

Commençons par créer un projet support pour la présente section et pour la suivante consacrée à String et str :

cargo new projet_car_chaine --bin 
     Created binary (application) `projet_car_chaine` package 

Rust fournit plusieurs méthodes visant à connaître la nature d’un caractère. Ces méthodes permettent ainsi de préciser si le caractère est numérique (is_numeric), alphabétique (is_alphabetic), alphanumérique (is_alphanumeric), ou encore s’il est un caractère espace (is_whitespace) ou un caractère dit « de contrôle » (is_control).

On crée donc des variables stockant des caractères, c’est-à-dire quelque chose stocké sur 32 bits, par défaut sur la pile :

fn main() { 
 
    // Des caractères. 
    let quatre = '4'; 
    println!("'4' est numérique ? : {}", quatre.is_numeric()); 
 
    let a = 'a'; 
    println!("'a' est alphabétique ? : {}", a.is_alphabetic()); 
 
    let etoile...

1. Introduction

Rappelons que ces deux types chaînes de caractères n’incluent que des valeurs UTF-8 bien formées, c’est-à-dire que le compilateur Rust garantit cela. Toutes les opérations conduites sur des types chaînes de caractères (String ou str) sont garanties et maintiennent un contenu bien formé au sens de UTF-8.

2. Le type str

Le type str ou plutôt &str correspond à une séquence d’octets en UTF-8 qui est non mutable. Par ailleurs, la taille de la chaîne de caractères n’est pas connue (contrairement à String). C’est ce que l’on appelle une tranche (slice) de chaîne de caractères.

La documentation en ligne de ce type est disponible à cette adresse : https://doc.rust-lang.org/std/str/index.html

On peut définir ce type de façon implicite, mais on peut également le préciser de manière explicite en indiquant &’static str.

fn fonction_str() { 
    let valeur_str = "bonjour"; 
    println!("valeur_str : {}", valeur_str); 
 
    let valeur_str_2 : &'static str = "BONJOUR"; 
    println!("valeur_str_2 : {}", valeur_str_2); 
} 

En sortie, on obtient ceci :

valeur_str : bonjour 
valeur_str_2 : BONJOUR 

Le type &str n’est pas de taille fixe, ni en réalité de taille connue. Il ne peut donc implémenter le trait Clone. Si l’on veut copier une valeur de ce type, il faut recourir à un autre trait : ToOwned. Ainsi, on peut utiliser la méthode to_owned, qui renvoie une copie de la chaîne de caractères :

let valeur_str_3 = valeur_str_2.to_owned(); 
println!("valeur_str_3 : {}", valeur_str_3); 

On peut également étudier une chaîne de caractères de type &str en ayant recours aux tranches. On accède à la valeur de diverses tranches. On peut vérifier également la longueur d’une tranche et inspecter son contenu :

println!("&valeur_str_3[..3] : {}", &valeur_str_3[..3]); 
println!("&valeur_str_3[3..] : {}", &valeur_str_3[3..]); ...