Rust Slice (tronçon) type

Un tronçon (Slice) est une référence partielle à une valeur de données.

Le type Slice de Rust (tronçon)

Tronçon (Slice)

Le nom de tronçon apparaît souvent en cours de biologie, lorsque nous fabriquons des coupes de cellules, nous devons prélever des tronçons de l'organisme pour les observer au microscope. Dans Rust, le sens de tronçon est à peu près le même, mais il tire des données en référence.

fn main() {
　　　　Tronçon de chaîne
　　　　let s = String::from("broadcast");1　Le type de tronçon de données le plus simple et le plus couramment utilisé est le tronçon de chaîne de caractères (String Slice).5];
　　　　let s = String::from("broadcast");2　let part = &s[5= &s[9];
　　　　println!("{}={}+{}", s, part1, part2);
}

Résultat de l'exécution :

broadcast=broad+cast

L'image ci-dessus explique le principe de la tronçon de chaîne de caractères (note : le type de chaîne de caractères dans Rust enregistre en réalité la position de départ et la longueur des caractères en mémoire, nous avons pour le moment seulement compris cela).

L'utilisation de la syntaxe .. pour représenter une plage a été mentionnée dans la section sur les boucles.x..y représente [x, y) le sens mathématique. .. peut ne pas avoir d'opérandes :

..y est équivalent à 0..y
x.. est équivalent à la position x à la fin des données
.. est équivalent à la position 0 à la fin

Attention :À ce jour, évitez de utiliser des caractères non-anglais dans les chaînes de caractères, car il y a des problèmes de codage. Les raisons spécifiques seront décrites dans la section "Chaîne".

La valeur de la chaîne de caractères pointée par le tronçon est interdite de modification :

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

Ce programme est incorrect.

s est partiellement cité, son valeur est interdite de modification.

实际上，到目前为止你一定疑惑为什么每一次使用字符串都要这样写String::from("w3en fait, jusqu'à maintenant, vous devez être intrigué par pourquoi chaque fois que vous utilisez une chaîne, vous devez écrire ainsi String::from("w")) codebox) , écrivez directement3"w codebox"

Ne va pas ?

Jusqu'ici, nous devons distinguer la différence de concept entre ces deux. Dans Rust, il existe deux types de chaînes couramment utilisés : str et String. str est un type de langage de noyau Rust, c'est-à-dire le tranchage de chaîne (String Slice) que nous avons toujours mentionné dans ce chapitre, qui apparaît souvent sous forme de référence (&str). Toute constante de chaîne encadrée par des guillemets doubles a une nature de type globale :&str

:

let s = "hello";

Ici, s est une variable de type &str.

String et str supportent toutes deux les tranches, et le résultat des tranches est de type &str. Le type String est un type de données fourni par la bibliothèque publique standard Rust, dont les fonctionnalités sont plus complètes - il prend en charge des opérations pratiques telles que l'ajout de chaînes et le vidage. En plus d'avoir une propriété de position de début de caractère et une propriété de longueur de chaîne, String et str ont également une propriété de capacité (capacity).

Attention : le résultat de la tranche doit être de type de type de référence, mais le développeur doit le faire savoir explicitement :

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

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

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

Tranches non-chaînes

En plus des chaînes, d'autres structures de données linéaires supportent les opérations de tranches, par exemple les tableaux :

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

Résultat de l'exécution :

1
3
5