Type Slice Rust

Une tranche est une référence partielle à une valeur de données.

Le nom « slice » apparaît souvent en cours de biologie. Lors de la préparation de lames d'échantillons, nous devons prélever des tranches d'un organisme pour les observer au microscope. En Rust, une tranche signifie à peu près la même chose, sauf qu'elle prend une référence à partir des données.

Tranche de chaîne

Le type de tranche de données le plus simple et le plus couramment utilisé est la tranche de chaîne (String Slice).

Exemple

fn main() {
    let s = String::from("broadcast");

    let part1 = &s[0..5];
    let part2 = &s[5..9];

    println!("{}={}+{}", s, part1, part2);
}

Sortie :

broadcast=broad+cast

Le diagramme ci-dessus explique le principe du découpage de chaîne (Remarque : le type String en Rust enregistre essentiellement la position de départ et la longueur des caractères en mémoire ; nous avons seulement besoin de comprendre cela pour le moment).

Utilisation..La syntaxe pour exprimer les intervalles est apparue dans le chapitre sur les boucles.x..yreprésente[x, y)la signification mathématique de...L'opérande peut être omis des deux côtés :

..y 等价于 0..y
x.. 等价于位置 x 到数据结束
.. 等价于位置 0 到结束

Remarque :Pour l'instant, essayez de ne pas utiliser de caractères non anglais dans les chaînes, en raison de problèmes d'encodage. Les raisons précises seront expliquées dans le chapitre « String ».

Il est interdit de modifier la valeur de la chaîne référencée par une slice :

Exemple

fn main() {
    let mut s = String::from("example");
    let slice = &s[0..3];
    s.push_str("yes!"); // Erreur
    println!("slice = {}", slice);
}

Ce programme est incorrect.

s est partiellement référencé, donc la modification de sa valeur est interdite.

En fait, à ce stade, vous devez vous demander pourquoi chaque fois que nous utilisons une chaîne, nous devons l'écrire comme ceciString::from("example"), et pourquoi écrire simplement"example"ne fonctionnerait pas ?

À ce stade, nous devons distinguer la différence conceptuelle entre ces deux. En Rust, il existe deux types de chaînes couramment utilisés : str et String. str est un type du langage de base de Rust, qui est la tranche de chaîne (String Slice) abordée tout au long de ce chapitre, et il apparaît souvent sous la forme d'une référence (&str).

Toute constante de chaîne entre guillemets doubles a pour type global&str：

let s = "hello";

Ici, s est une variable de type &str.

Le type String est un type de données fourni par la bibliothèque publique standard de Rust, et ses fonctionnalités sont plus complètes — il prend en charge des opérations pratiques telles que l'ajout et l'effacement de chaînes. En plus de l'attribut de position de début des caractères et de l'attribut de longueur de chaîne que String et str partagent, String possède également un attribut de capacité.

String et str prennent tous deux en charge le découpage, et le résultat du découpage est une donnée de type &str.

Remarque : le résultat du découpage doit être un type de référence, mais le développeur doit l'indiquer explicitement :

let slice = &s[0..3];

Il existe un moyen rapide de convertir String en &str :

let s1 = String::from("hello");
let s2 = &s1[..];

Tranche non-String

En plus des chaînes, d'autres structures de données linéaires prennent également en charge les opérations de découpage, telles que les tableaux :

Exemple

fn main() {
    let arr = [1, 3, 5, 7, 9];
    let part = &arr[0..3];
    for i in part.iter() {
        println!("{}", i);
    }
}

Sortie :

1
3
5
Autres extensions