Déstructuration
Structures, énumérations, tuples
Déstructuration est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que la déstructuration ?
La déstructuration sépare une valeur composée en ses éléments à l'aide d'un motif. Elle fonctionne avec les tuples, les structures, les énumérations, les tableaux et bien plus encore.
Déstructurer des tuples
Liez chaque élément d'un tuple à sa propre variable dans un seul let.
fn main() {
let point = (3, 7);
let (x, y) = point;
println!("x = {x}, y = {y}");
}Ignorer des éléments d'un tuple
Utilisez _ pour ignorer une valeur et .. pour en ignorer plusieurs.
fn main() {
let data = (1, 2, 3, 4);
let (first, .., last) = data;
println!("{first} ... {last}");
}Déstructurer des structures
Extrayez les champs d'une structure par leur nom. Les noms des variables liées peuvent être identiques à ceux des champs ou être renommés.
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 10, y: 20 };
let Point { x, y } = p;
println!("{x}, {y}");
}Renommer des champs
Utilisez field: new_name pour lier un champ de structure à un autre nom de variable.
struct Config {
width: u32,
height: u32,
}
fn main() {
let c = Config { width: 800, height: 600 };
let Config { width: w, height: h } = c;
println!("{w} x {h}");
}Ignorer des champs de structure
.. ignore les champs restants dont vous n'avez pas besoin.
struct User {
name: String,
age: u32,
active: bool,
}
fn main() {
let u = User { name: "Ada".into(), age: 36, active: true };
let User { name, .. } = u;
println!("{name}");
}Déstructurer des énumérations
Dans un match, déstructurez les variantes d'une énumération pour en extraire les données.
enum Event {
Click { x: i32, y: i32 },
Key(char),
}
fn main() {
let e = Event::Click { x: 5, y: 8 };
match e {
Event::Click { x, y } => println!("click at {x},{y}"),
Event::Key(c) => println!("key {c}"),
}
}Déstructurer dans des paramètres
Les paramètres de fonction peuvent être déstructurés directement, ce qui est pratique pour les tuples et les petites structures.
fn distance((x1, y1): (f64, f64), (x2, y2): (f64, f64)) -> f64 {
((x2 - x1).powi(2) + (y2 - y1).powi(2)).sqrt()
}
fn main() {
println!("{}", distance((0.0, 0.0), (3.0, 4.0)));
}Déstructuration imbriquée
Les motifs s'imbriquent librement, ce qui vous permet d'accéder en une seule étape à des éléments profondément enfouis dans les structures.
struct Line {
start: (i32, i32),
end: (i32, i32),
}
fn main() {
let line = Line { start: (0, 0), end: (4, 5) };
let Line { start: (sx, sy), end: (ex, ey) } = line;
println!("from {sx},{sy} to {ex},{ey}");
}Déstructurer des tableaux et des tranches
Les tableaux et les tranches peuvent être déstructurés, notamment en capturant la partie centrale avec ...
fn main() {
let arr = [1, 2, 3, 4, 5];
let [first, .., last] = arr;
println!("first {first}, last {last}");
}Déstructurer dans des boucles for
La déstructuration fonctionne également dans les boucles for, ce qui est parfait pour parcourir des paires de valeurs.
fn main() {
let pairs = [("a", 1), ("b", 2), ("c", 3)];
for (label, value) in pairs {
println!("{label} = {value}");
}
}Vérification rapide
Comment ignorer les champs restants d'une structure lors de sa déstructuration ?
Récapitulatif
Vous avez appris la déstructuration :
- Séparer des tuples, des structures, des énumérations, des tableaux et des tranches
- Renommer des champs avec
field: name - Ignorer des éléments avec
_et.. - Déstructurer dans
let,matchet les paramètres de fonction - Imbriquer les motifs pour extraire des éléments en profondeur
Questions Fréquemment Posées
La leçon « Déstructuration » est-elle gratuite ?
Oui — le texte complet de « Déstructuration » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Déstructuration » ?
Structures, énumérations, tuples Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Déstructuration » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.